1 /* The C++ exceptions runtime support

     2  *

     3  * Copyright 2002-2005 ARM Limited. All rights reserved.

     4  *

     5  * Your rights to use this code are set out in the accompanying licence

     6  * text file LICENCE.txt (ARM contract number LEC-ELA-00080 v1.0).

     7  */

     8 

     9 /* Portions copyright Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). */

    10 

    11 /*

    12  * RCS $Revision: 92950 $

    13  * Checkin $Date: 2005-10-12 11:08:47 +0100 (Wed, 12 Oct 2005) $

    14  * Revising $Author: achapman $

    15  */

    16 

    17 /* This source file is compiled automatically by ARM's make system into

    18  * multiple object files. The source regions constituting object file

    19  * xxx.o are delimited by ifdef xxx_c / endif directives.

    20  *

    21  * The source regions currently marked are:

    22  * arm_exceptions_globs_c

    23  * arm_exceptions_mem_c

    24  * arm_exceptions_uncaught_c

    25  * arm_exceptions_terminate_c

    26  * arm_exceptions_setterminate_c

    27  * arm_exceptions_unexpected_c

    28  * arm_exceptions_setunexpected_c

    29  * arm_exceptions_support_c

    30  * arm_exceptions_callterm_c

    31  * arm_exceptions_callunex_c

    32  * arm_exceptions_currenttype_c

    33  * arm_exceptions_alloc_c

    34  * arm_exceptions_free_c

    35  * arm_exceptions_throw_c

    36  * arm_exceptions_rethrow_c

    37  * arm_exceptions_foreign_c

    38  * arm_exceptions_cleanup_c

    39  * arm_exceptions_getexceptionptr_c

    40  * arm_exceptions_begincatch_c

    41  * arm_exceptions_endcatch_c

    42  * arm_exceptions_bad_typeid_c

    43  * arm_exceptions_bad_cast_c

    44  */

    45 

    46 #include <string.h>

    47 

    48 // Environment:

    49 #include "unwind_env.h"

    50 // Language-independent unwinder declarations:

    51 #include "unwinder.h"

    52 

    53 #ifdef __EPOC32__

    54 /* Symbian specific support */

    55 #include "symbian_support.h"

    56 #endif

    57 

    58 #include <new>

    59 

    60 /* Barrier cache: */

    61 /* Requirement imposed by C++ semantics module - pointer to match object in slot 0: */

    62 #define BARRIER_HANDLEROBJECT (0)

    63 /* Requirement imposed by C++ semantics module - function exception spec info */

    64 #define BARRIER_FNSPECCOUNT  (1)

    65 #define BARRIER_FNSPECBASE   (2)

    66 #define BARRIER_FNSPECSTRIDE (3)

    67 #define BARRIER_FNSPECARRAY  (4)

    68 

    69 /* By default, none of these routines are unwindable: */

    70 #pragma noexceptions_unwind

    71 

    72 /* For brevity: */

    73 

    74 typedef _Unwind_Control_Block UCB;

    75 

    76 using std::terminate_handler;

    77 using std::unexpected_handler;

    78 using std::terminate;

    79 using std::unexpected;

    80 using std::type_info;

    81 

    82 /* Redeclare these interface routines as weak, so using them does not

    83  * pull in the unwind library. We only want the unwind library if

    84  * someone throws (or raises an exception from some other language).

    85  */

    86 WEAKDECL NORETURNDECL void _Unwind_Resume(UCB *);

    87 WEAKDECL void _Unwind_Complete(UCB *);

    88 

    89 /* Diagnostics:

    90  * Define DEBUG to get extra interfaces which assist debugging this functionality.

    91  * Define CPP_DIAGNOSTICS for printed diagnostics.

    92  */

    93 #ifdef DEBUG

    94 #define CPP_DIAGNOSTICS

    95 #endif

    96 

    97 #ifdef CPP_DIAGNOSTICS

    98 #ifndef __EPOC32__

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

   100 #endif

   101 #endif

   102 

   103 /* --------- "Exceptions_class" string for our implementation: --------- */

   104 

   105 #define EXCEPTIONS_CLASS_SIZE 8

   106 #define ARMCPP_EXCEPTIONS_CLASS "ARM\0C++\0"

   107 

   108 

   109 /* --------- Exception control object: --------- */

   110 

   111 // Type __cxa_exception is the combined C++ housekeeping (LEO) and UCB.

   112 // It will be followed by the user exception object, hence must ensure

   113 // the latter is aligned on an 8 byte boundary.

   114 

   115 #ifndef __EPOC32__

   116 struct __cxa_exception {

   117   const type_info *exceptionType;       // RTTI object describing the type of the exception

   118   void *(*exceptionDestructor)(void *); // Destructor for the exception object (may be NULL)

   119   unexpected_handler unexpectedHandler; // Handler in force after evaluating throw expr

   120   terminate_handler terminateHandler;   // Handler in force after evaluating throw expr

   121   __cxa_exception *nextCaughtException; // Chain of "currently caught" c++ exception objects

   122   uint32_t handlerCount;                // Count of how many handlers this EO is "caught" in

   123   __cxa_exception *nextPropagatingException; // Chain of objects saved over cleanup

   124   uint32_t propagationCount;            // Count of live propagations (throws) of this EO

   125   UCB ucb;                              // Forces alignment of next item to 8-byte boundary

   126 };

   127 #endif

   128 

   129 

   130 /* --------- Control "globals": --------- */

   131 

   132 // We do this by putting all the thread-specific "globals" into a single

   133 // area of store, which we allocate space for dynamically.

   134 // We don't define a constructor for this; see comments with __cxa_get_globals.

   135 

   136 #ifndef __EPOC32__

   137 typedef void (*handler)(void);

   138 

   139 struct __cxa_eh_globals {

   140   uint32_t uncaughtExceptions;               // counter

   141   unexpected_handler unexpectedHandler;      // per-thread handler

   142   terminate_handler terminateHandler;        // per-thread handler

   143   bool implementation_ever_called_terminate; // true if it ever did

   144   handler call_hook;     // transient field to tell terminate/unexpected which hook to call

   145   __cxa_exception *caughtExceptions;         // chain of "caught" exceptions

   146   __cxa_exception *propagatingExceptions;    // chain of "propagating" (in cleanup) exceptions

   147   void *emergency_buffer;                    // emergency buffer for when rest of heap full

   148 };

   149 #endif

   150 

   151 

   152 /* ---------- Entry points: ---------- */

   153 

   154 /* There is a little type-delicacy required here as __cxa_throw takes a

   155  * function pointer. Setting aside the problem of not being able to form

   156  * a pointer to a destructor in C++, if we simply say extern "C" here

   157  * then the function pointer will also have C linkage and will be a

   158  * pointer to a C function. This causes problems when __cxa_throw is

   159  * defined (unless we repeat the extern "C" at the definition site) because

   160  * the fnptr in the definition gets C++ linkage, hence that __cxa_throw has

   161  * a different signature to the declared one, and so the function we wanted

   162  * doesn't get defined at all.

   163  * Maybe it should just take a void * but this seems more honest.

   164  */

   165 

   166 typedef void *(*cppdtorptr)(void *);

   167 

   168 extern "C" {

   169 

   170   // Protocol routines called directly from application code

   171 

   172   IMPORT_C void *__cxa_allocate_exception(size_t size);

   173   IMPORT_C void __cxa_free_exception(void *);

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

   175   IMPORT_C void __cxa_rethrow(void);

   176   IMPORT_C void *__cxa_get_exception_ptr(UCB *);

   177   void *__cxa_begin_catch(UCB *);

   178   IMPORT_C void __cxa_end_catch(void);

   179   IMPORT_C void __cxa_end_cleanup(void);

   180   IMPORT_C const type_info *__cxa_current_exception_type(void);

   181 

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

   183 

   184   IMPORT_C void __cxa_call_terminate(UCB *);

   185   IMPORT_C void __cxa_call_unexpected(UCB *);

   186   IMPORT_C bool __cxa_begin_cleanup(UCB *);

   187   typedef enum {

   188     ctm_failed = 0,

   189     ctm_succeeded = 1,

   190     ctm_succeeded_with_ptr_to_base = 2

   191   } __cxa_type_match_result;

   192   IMPORT_C __cxa_type_match_result __cxa_type_match(UCB *, const std::type_info *,

   193                                                     bool is_reference_type, void **);

   194 

   195   // Auxilliary routines

   196 

   197   __cxa_eh_globals *__cxa_get_globals(void);

   198   IMPORT_C void __cxa_bad_typeid(void);

   199   IMPORT_C void __cxa_bad_cast(void);

   200 

   201   // Emergency memory buffer management routines

   202 

   203   void *__ARM_exceptions_buffer_init(void);

   204   void *__ARM_exceptions_buffer_allocate(void *, size_t);

   205   void *__ARM_exceptions_buffer_free(void *, void *);

   206 }

   207 

   208 

   209 // Support routines

   210 

   211 #define NAMES __ARM

   212 namespace NAMES {

   213   void default_unexpected_handler(void);

   214   void call_terminate_handler(UCB *);

   215   void eh_catch_semantics(UCB *);

   216   bool is_foreign_exception(UCB *);

   217   bool same_exceptions_class(const void *, const void *);

   218   __cxa_exception *get_foreign_intermediary(__cxa_exception *, UCB *);

   219 }

   220 

   221 // Macro: convert ucb pointer to __cxa_exception pointer

   222 

   223 #define ucbp_to_ep(UCB_P) ((__cxa_exception *)((char *)(UCB_P) - offsetof(__cxa_exception, ucb)))

   224 

   225 

   226 #ifdef arm_exceptions_globs_c

   227 

   228 /* --------- Allocating and retrieving "globals": --------- */

   229 

   230 // The exception-handling globals should be allocated per-thread.

   231 // This is done here assuming the existance of a zero-initialised void*

   232 // pointer location obtainable by the macro EH_GLOBALS.

   233 

   234 // Default terminate handler:

   235 

   236 #ifndef __EPOC32__

   237 static void __default_terminate_handler(void) {

   238   abort();

   239 }

   240 #endif

   241 

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

   243 namespace NAMES { WEAKDECL void default_unexpected_handler(void); }

   244 

   245 // ARM's toolchain documentation states that if symbol

   246 // __ARM_exceptions_buffer_required is present we should allocate

   247 // an emergency buffer.

   248 // As we aren't allowed static data in ARM library builds, reference the

   249 // symbol by declaring it a function. This causes an additional problem when

   250 // ARM libraries are built position-independent, namely that an absent

   251 // function doesn't compare address-equal to NULL. So we have to get the

   252 // "addresses" from two different compilation units and compare those.

   253 // This is a known defect, to be fixed in the compiler.

   254 extern "C" WEAKDECL void __ARM_exceptions_buffer_required(void);

   255 extern void (*(__ARM_exceptions_buffer_required_address(void)))(void);

   256 

   257 // The address comparison function only needs to be used when we are building 

   258 // position-independent.  In other cases, comparing the address to NULL is more

   259 // efficient.

   260 #if 0

   261 #  define ARM_EXCEPTIONS_BUFFER_NOT_REQUIRED() (&__ARM_exceptions_buffer_required != __ARM_exceptions_buffer_required_address())

   262 #else

   263 #  define ARM_EXCEPTIONS_BUFFER_NOT_REQUIRED() (&__ARM_exceptions_buffer_required == NULL)

   264 #endif

   265 

   266 // __cxa_eh_globals returns the per-thread memory. There are several complications,

   267 // all of which relate to not touching the exceptions system while trying to

   268 // initialise it:

   269 // 1) We can't obtain memory by calling new or nothrow new as both of these use

   270 //    exceptions internally, so we must use malloc

   271 // 2) We choose not to initialise the memory via placement new and a constructor,

   272 //    since placement new is declared with an empty function exception specification,

   273 //    which causes more of the exceptions system to always be pulled in.

   274 // 3) We can't call terminate, as terminate looks in the memory we are trying to

   275 //    allocate.

   276 

   277 EXPORT_C __cxa_eh_globals *__cxa_get_globals(void)

   278 {

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

   280 

   281 #ifndef __EPOC32__

   282   /* The Symbian implementation allocates the required space on the threads stack

   283      at thread creation and sets up thread local storage to point to the globals

   284      which are also initialised

   285   */

   286   if (this_thread_globals == NULL) {

   287 

   288     // First call

   289     // Obtain some memory: this is thread-safe provided malloc is.

   290     this_thread_globals = (__cxa_eh_globals *)malloc(sizeof(__cxa_eh_globals));

   291     if (this_thread_globals == NULL) abort(); // NOT terminate(), which calls this fn

   292 

   293     // Save the pointer in the specially-provided location

   294     EH_GLOBALS = this_thread_globals;

   295 

   296     // Finally initialise the memory by hand

   297     this_thread_globals->uncaughtExceptions = 0;

   298     this_thread_globals->unexpectedHandler = NAMES::default_unexpected_handler;

   299     this_thread_globals->terminateHandler = __default_terminate_handler;

   300     this_thread_globals->implementation_ever_called_terminate = false;

   301     this_thread_globals->call_hook = NULL;

   302     this_thread_globals->caughtExceptions = NULL;

   303     this_thread_globals->propagatingExceptions = NULL;

   304     if (ARM_EXCEPTIONS_BUFFER_NOT_REQUIRED())

   305       this_thread_globals->emergency_buffer = NULL;

   306     else

   307       this_thread_globals->emergency_buffer = __ARM_exceptions_buffer_init();

   308   }

   309 #endif

   310   return this_thread_globals;

   311 }

   312 

   313 

   314 #endif /* arm_exceptions_globs_c */

   315 #ifdef arm_exceptions_mem_c

   316 

   317 /* --------- Emergency memory: --------- */

   318 

   319 // It is possible to reserve memory for throwing bad_alloc when the heap

   320 // is otherwise full. The ARM implementation provides hooks to do this.

   321 // The default implementation reserves just enough space for a bad_alloc

   322 // object, so if memory is later exhausted bad_alloc can still be thrown.

   323 // Note there is no guarantee or requirement that the exception being

   324 // thrown is actually bad_alloc.

   325 

   326 // A usage flag and enough space for a bad_alloc exception control object

   327 #ifndef __EPOC32__

   328 struct emergency_eco {

   329   __cxa_exception ep;

   330   std::bad_alloc b;

   331 };

   332 

   333 struct emergency_buffer {

   334   bool inuse;

   335   struct emergency_eco eco;

   336 };

   337 

   338 #endif

   339 

   340 #ifndef __EPOC32__

   341 // The SymbianOS implementation allocates this space at thread creation

   342 

   343 // Initialiser

   344 void* __ARM_exceptions_buffer_init(void)

   345 {

   346   emergency_buffer *buffer = (emergency_buffer *)malloc(sizeof(emergency_buffer));

   347   if (buffer == NULL) return NULL;

   348   buffer->inuse = false;

   349   return buffer;

   350 }

   351 #endif

   352 

   353 // Allocator

   354 void *__ARM_exceptions_buffer_allocate(void *buffer, size_t size)

   355 {

   356   emergency_buffer *b = (emergency_buffer *)buffer;

   357   if (size > sizeof(emergency_eco) || b == NULL || b->inuse) return NULL;

   358   b->inuse = true;

   359   return &b->eco;

   360 }

   361 

   362 // Deallocator: Must return non-NULL if and only if it recognises

   363 // and releases the supplied object

   364 void *__ARM_exceptions_buffer_free(void *buffer, void *addr)

   365 {

   366   emergency_buffer *b = (emergency_buffer *)buffer;

   367   if (b == NULL || addr != &b->eco) return NULL;

   368   b->inuse = false;

   369   return b;

   370 }

   371 

   372 #  if 0

   373 // Hook activation support - see comments earlier

   374 extern "C" WEAKDECL void __ARM_exceptions_buffer_required(void);

   375 void (*(__ARM_exceptions_buffer_required_address(void)))(void)

   376 {

   377   return &__ARM_exceptions_buffer_required;

   378 }

   379 #  endif

   380 

   381 

   382 #endif /* arm_exceptions_mem_c */

   383 #ifdef arm_exceptions_uncaught_c

   384 

   385 /* ---- uncaught_exception() ---- */

   386 

   387 /* The EDG (and I think our) interpretation is that if the implementation

   388  * ever called terminate(), uncaught_exception() should return true.

   389  */

   390 #if __ARMCC_VERSION < 220000

   391 bool std::uncaught_exception(void)

   392 #else

   393 EXPORT_C bool std::uncaught_exception(void)

   394 #endif

   395 {

   396    __cxa_eh_globals *g = __cxa_get_globals();

   397    return g->implementation_ever_called_terminate || g->uncaughtExceptions;

   398 }

   399 

   400 

   401 #endif /* arm_exceptions_uncaught_c */

   402 #ifdef arm_exceptions_terminate_c

   403 

   404 /* ---- terminate() etc ---- */

   405 

   406 /* The behaviour of terminate() must differ between calls by the

   407  * implementation and calls by the application. This is achieved by having the

   408  * implementation set call_hook immediately before the call to terminate().

   409  * The hook called by terminate() should terminate the program without

   410  * returning to the caller. There is no requirement for terminate() itself to

   411  * intercept throws.

   412  */

   413 

   414 EXPORT_C void std::terminate(void)

   415 {

   416   __cxa_eh_globals *g = __cxa_get_globals();

   417 

   418   if (g->call_hook != NULL) {

   419     // Clear then call hook fn we were passed

   420     handler call_hook = g->call_hook;

   421     g->call_hook = NULL;

   422     call_hook();

   423   } else {

   424     // Call global hook fn

   425     g->terminateHandler();

   426   }

   427   // If hook fn returns:

   428   abort();

   429 }

   430 

   431 

   432 #endif /* arm_exceptions_terminate_c */

   433 #ifdef arm_exceptions_setterminate_c

   434 

   435 EXPORT_C terminate_handler std::set_terminate(terminate_handler h) throw()

   436 {

   437   __cxa_eh_globals *g = __cxa_get_globals();

   438   terminate_handler old = g->terminateHandler;

   439   g->terminateHandler = h;

   440   return old;

   441 }

   442 

   443 

   444 #endif /* arm_exceptions_setterminate_c */

   445 #ifdef arm_exceptions_unexpected_c

   446 

   447 /* ---- unexpected() etc ---- */

   448 /* Comments as per terminate() */

   449 

   450 void NAMES::default_unexpected_handler(void) {

   451   terminate();

   452 }

   453 

   454 #pragma exceptions_unwind

   455 

   456 EXPORT_C void std::unexpected(void)

   457 {

   458   __cxa_eh_globals *g = __cxa_get_globals();

   459 

   460   if (g->call_hook != NULL) {

   461     // Clear then call hook fn we were passed

   462     handler call_hook = g->call_hook;

   463     g->call_hook = NULL;

   464     call_hook();

   465   } else {

   466     // Call global hook fn

   467     g->unexpectedHandler();

   468   }

   469 

   470   // If hook fn returns:

   471   abort();

   472 }

   473 

   474 

   475 #endif /* arm_exceptions_unexpected_c */

   476 #ifdef arm_exceptions_setunexpected_c

   477 

   478 EXPORT_C unexpected_handler std::set_unexpected(unexpected_handler h) throw()

   479 {

   480   __cxa_eh_globals *g = __cxa_get_globals();

   481   unexpected_handler old = g->unexpectedHandler;

   482   g->unexpectedHandler = h;

   483   return old;

   484 }

   485 

   486 

   487 #endif /* arm_exceptions_setunexpected_c */

   488 #ifdef arm_exceptions_support_c

   489 

   490 /* ---------- Helper functions: ---------- */

   491 

   492 /* Two routines to determine whether two exceptions objects share a layout.

   493  * This is determined by checking whether the UCB exception_class members

   494  * are identical.

   495  * In principle we could use memcmp to perform this check (the code is

   496  * given below) but the check is quite frequent and so that is costly.

   497  * Therefore for efficiency we make use of the fact that the UCB is

   498  * word aligned, that the exception_class member is consequently

   499  * word aligned within it, and that we know the size of the member.

   500  * We take care elsewhere to only ever call the routines with pointers

   501  * to word-aligned addresses.

   502  */

   503 

   504 #if 0

   505 

   506 // Straightforward versions

   507 

   508 bool NAMES::same_exceptions_class(const void *ec1, const void *ec2)

   509 {

   510   return memcmp(ec1, ec2, EXCEPTIONS_CLASS_SIZE) == 0; // identical

   511 }

   512 

   513 // One of our exception objects, or not?

   514 

   515 bool NAMES::is_foreign_exception(UCB *ucbp)

   516 {

   517   return !NAMES::same_exceptions_class(&ucbp->exception_class, ARMCPP_EXCEPTIONS_CLASS);

   518 }

   519 

   520 #else

   521 

   522 // Faster versions

   523 

   524 bool NAMES::same_exceptions_class(const void *ec1, const void *ec2)

   525 {

   526   uint32_t *ip1 = (uint32_t *)ec1;

   527   uint32_t *ip2 = (uint32_t *)ec2;

   528   return ip1[0] == ip2[0] && ip1[1] == ip2[1];

   529 }

   530 

   531 // One of our exception objects, or not?

   532 

   533 bool NAMES::is_foreign_exception(UCB *ucbp)

   534 {

   535   // Need a word-aligned copy of the string

   536   static const union {

   537     const char s[EXCEPTIONS_CLASS_SIZE+1]; int dummy;

   538   } is_foreign_exception_static = {ARMCPP_EXCEPTIONS_CLASS};

   539   return !NAMES::same_exceptions_class(&ucbp->exception_class, &is_foreign_exception_static.s);

   540 }

   541 

   542 #endif

   543 

   544 

   545 #endif /* arm_exceptions_support_c */

   546 #ifdef arm_exceptions_callterm_c

   547 

   548 /* When the implementation wants to call terminate(), do the following:

   549  * Mark the object as "caught" so it can be rethrown.

   550  * Set the hook function for terminate() to call;

   551  * Mark the fact that terminate() has been called by the implementation;

   552  * We have to be careful - the implementation might encounter an error while

   553  * unwinding a foreign exception, and also it is possible this might be

   554  * called after failing to obtain a ucb.

   555  */

   556 

   557 void NAMES::call_terminate_handler(UCB *ucbp)

   558 {

   559   __cxa_eh_globals *g = __cxa_get_globals();

   560 

   561   if (ucbp == NULL) {

   562     // Call global hook

   563     g->call_hook = g->terminateHandler;

   564   } else {

   565     // Extract the hook to call

   566     if (NAMES::is_foreign_exception(ucbp)) {

   567       // Someone else's

   568       g->call_hook = g->terminateHandler;  // best we can do under the circumstances

   569     } else {

   570       // One of ours

   571       __cxa_exception *ep = ucbp_to_ep(ucbp);

   572       g->call_hook = ep->terminateHandler; // the one in force at the point of throw

   573     }

   574   }

   575 

   576   g->implementation_ever_called_terminate = true;

   577   terminate();

   578   // never returns

   579 }

   580 

   581 

   582 EXPORT_C void __cxa_call_terminate(UCB *ucbp)

   583 {

   584   if (ucbp != NULL) // Record entry to (implicit) handler

   585     __cxa_begin_catch(ucbp);

   586 

   587   NAMES::call_terminate_handler(ucbp);

   588   // never returns

   589 }

   590 

   591 

   592 #endif /* arm_exceptions_callterm_c */

   593 #ifdef arm_exceptions_callunex_c

   594 

   595 /* When the implementation wants to call unexpected(), do the following:

   596  * Mark the object as "caught" so it can be rethrown.

   597  * Set the hook function for unexpected() to call;

   598  * Call unexpected and trap any throw to make sure it is acceptable.

   599  * We have to be careful - the implementation might encounter an error while

   600  * unwinding a foreign exception.

   601  */

   602 

   603 #pragma exceptions_unwind

   604 

   605 EXPORT_C void __cxa_call_unexpected(UCB *ucbp)

   606 {

   607 

   608   // Extract data we will need from the barrier cache before

   609   // anyone has a chance to overwrite it

   610 

   611   uint32_t rtti_count = ucbp->barrier_cache.bitpattern[BARRIER_FNSPECCOUNT];

   612   uint32_t base = ucbp->barrier_cache.bitpattern[BARRIER_FNSPECBASE];

   613   uint32_t stride = ucbp->barrier_cache.bitpattern[BARRIER_FNSPECSTRIDE];

   614   uint32_t rtti_offset_array_addr = ucbp->barrier_cache.bitpattern[BARRIER_FNSPECARRAY];

   615 

   616   // Also get the globals here and the eop

   617 

   618   __cxa_eh_globals *g = __cxa_get_globals();

   619   __cxa_exception *ep = ucbp_to_ep(ucbp);

   620 

   621 #ifdef ARM_EXCEPTIONS_ENABLED

   622   try {

   623 #endif

   624 

   625     // Record entry to (implicit) handler

   626 

   627     __cxa_begin_catch(ucbp);

   628 

   629     // Now extract the hook to call

   630 

   631     if (NAMES::is_foreign_exception(ucbp)) {

   632       // Someone else's

   633       g->call_hook = g->unexpectedHandler;  // best we can do under the circumstances

   634     } else {

   635       // One of ours

   636       g->call_hook = ep->unexpectedHandler; // the one in force at the point of throw

   637     }

   638     unexpected();  // never returns normally, but might throw something

   639 

   640 #ifdef ARM_EXCEPTIONS_ENABLED

   641   } catch (...) {

   642 

   643     // Unexpected() threw. This requires some delicacy.

   644     // There are 2 possibilities:

   645     // i) rethrow of the same object

   646     // ii) throw of a new object

   647     // Unexpected() is an implicit handler, and we manually called

   648     // __cxa_begin_catch on the ingoing object. We need to call

   649     // __cxa_end_catch on that object and, if the object is no longer

   650     // being handled (possible in case ii), this will cause its destruction.

   651     // The wrinkle is that in case ii the object is not on top of the catch

   652     // stack because we just caught something else.

   653 

   654     // Get hold of what was thrown (which we just caught).

   655 

   656     __cxa_exception *epnew = g->caughtExceptions;

   657 

   658     // Call __cxa_end_catch on the original object, taking care with the catch chain

   659 

   660     if (epnew == ep) {

   661       // rethrow - easy & safe - object is at top of chain and handlercount > 1

   662       __cxa_end_catch();

   663     } else {

   664       // not rethrow - unchain the top (new) object, clean up the next one,

   665       // and put the top object back

   666 

   667       // unchain

   668       g->caughtExceptions = epnew->nextCaughtException;

   669       // assert g->caughtExceptions == ep now

   670       // Decrement its handlercount (this might call a dtor if the count goes to 0,

   671       // and the dtor might throw - if it does, just give up)

   672       try {

   673 	__cxa_end_catch();

   674       } catch(...) {

   675 	terminate();

   676       }

   677       // Chain back in

   678       epnew->nextCaughtException = g->caughtExceptions;

   679       g->caughtExceptions = epnew;

   680     }

   681 

   682     // See whether what was thrown is permitted, and in passing

   683     // see if std::bad_exception is permitted

   684 

   685     bool bad_exception_permitted = false;

   686     uint32_t i;

   687     for (i = 0; i < rtti_count; i++) {

   688       void *matched_object;

   689       type_info *fnspec;

   690       if (EHABI_V2(ucbp))

   691 	fnspec = (type_info *)__ARM_resolve_target2((void *)rtti_offset_array_addr);

   692       else

   693 	fnspec = (type_info *)(*(uint32_t *)rtti_offset_array_addr + base);

   694       if (__cxa_type_match(&(epnew->ucb), fnspec, false, &matched_object)) {

   695 #ifdef CPP_DIAGNOSTICS

   696 	printf("__cxa_call_unexpected: fnspec matched\n");

   697 #endif

   698 	throw; // got a match - propagate it

   699       }

   700       if (typeid(std::bad_exception) == *fnspec)

   701 	bad_exception_permitted = true;

   702       rtti_offset_array_addr += stride;

   703     }

   704 

   705     // There was no match...

   706     if (bad_exception_permitted) throw std::bad_exception(); // transmute

   707 

   708     // Otherwise call epnew's terminate handler

   709     NAMES::call_terminate_handler(&epnew->ucb);

   710   }

   711 #endif

   712 }

   713 

   714 

   715 #endif /* arm_exceptions_callunex_c */

   716 #ifdef arm_exceptions_currenttype_c

   717 

   718 /* Yield the type of the currently handled exception, or null if none or the

   719  * object is foreign.

   720  */

   721 

   722 EXPORT_C const type_info *__cxa_current_exception_type(void)

   723 {

   724   __cxa_eh_globals *g = __cxa_get_globals();

   725   __cxa_exception *ep = g->caughtExceptions;

   726   if (ep == NULL || NAMES::is_foreign_exception(&ep->ucb)) return NULL;

   727   return ep->exceptionType;

   728 }

   729 

   730 

   731 #endif /* arm_exceptions_currenttype_c */

   732 #ifdef arm_exceptions_alloc_c

   733 

   734 /* Allocate store for controlling an exception propagation */

   735 

   736 EXPORT_C void *__cxa_allocate_exception(size_t size)

   737 {

   738   __cxa_eh_globals *g = __cxa_get_globals();

   739 

   740   // Allocate store for a __cxa_exception header and the EO.

   741   // Allocated store should be thread-safe and persistent, and must do

   742   // something sensible if the allocation fails

   743 

   744   size_t total_size = size + sizeof(__cxa_exception);

   745   // coverity[alloc_fn]

   746   __cxa_exception *ep = (__cxa_exception *)malloc(total_size);

   747   if (ep == NULL) {

   748     // Try the emergency memory pool

   749     SYMBIAN_EH_SUPPORT_PRINTF("Trying emergency buffer: size %d\n", total_size);

   750     ep = (__cxa_exception *)__ARM_exceptions_buffer_allocate(g->emergency_buffer, total_size);

   751         

   752     if (ep == NULL) {

   753       SYMBIAN_EH_SUPPORT_PRINTF("Emergency buffer allocation failed. Terminating\n");

   754       NAMES::call_terminate_handler(NULL);

   755     }

   756   }

   757 

   758   UCB *ucbp = &ep->ucb;

   759 

   760   // Initialise the UCB

   761 

   762   memcpy(ucbp->exception_class, ARMCPP_EXCEPTIONS_CLASS, EXCEPTIONS_CLASS_SIZE);

   763   ucbp->exception_cleanup = NULL; /* initialise properly before throwing */

   764   ucbp->unwinder_cache.reserved1 = 0; /* required to do this */

   765 

   766   // Initialise parts of the LEO, in case copy-construction of the EO results

   767   // in a need to call terminate (via __cxa_call_terminate)

   768 

   769   ep->handlerCount = 0;                         // Not in any handlers

   770   ep->nextCaughtException = NULL;               // Not in any handlers

   771   ep->nextPropagatingException = NULL;          // Not saved over cleanup

   772   ep->propagationCount = 0;                     // Not propagating

   773   ep->terminateHandler = g->terminateHandler;   // Cache current terminate handler

   774   ep->unexpectedHandler = g->unexpectedHandler; // Cache current unexpected handler

   775 

   776   // Return pointer to the EO

   777   // coverity[memory_leak]

   778   return ep + 1;

   779 }

   780 

   781 

   782 #endif /* arm_exceptions_alloc_c */

   783 #ifdef arm_exceptions_free_c

   784 

   785 /* Free store allocated by __cxa_allocate_exception */

   786 

   787 EXPORT_C void __cxa_free_exception(void *eop)

   788 {

   789   __cxa_eh_globals *g = __cxa_get_globals();

   790   char *ep = (char *)eop - sizeof(__cxa_exception);

   791   if (__ARM_exceptions_buffer_free(g->emergency_buffer, ep)) return;

   792   free(ep);

   793 }

   794 

   795 

   796 #endif /* arm_exceptions_free_c */

   797 #ifdef arm_exceptions_throw_c

   798 

   799 /* This routine is called when a foreign runtime catches one of our exception

   800  * objects and then exits its catch by a means other than rethrow.

   801  * We should clean it up as if we had caught it ourselves.

   802  */

   803 

   804 static void external_exception_termination(_Unwind_Reason_Code c, UCB *ucbp)

   805 {

   806   NAMES::eh_catch_semantics(ucbp);

   807   __cxa_end_catch();

   808 }

   809 

   810 

   811 /* Initiate a throw */

   812 

   813 #pragma push

   814 #pragma exceptions_unwind

   815 

   816 EXPORT_C void __cxa_throw(void *eop, const type_info *t, cppdtorptr d)

   817 {

   818   __cxa_exception *ep = (__cxa_exception *)((char *)eop - sizeof(__cxa_exception));

   819   UCB *ucbp = &ep->ucb;

   820 

   821   // Initialise the remaining LEO and UCB fields not done by __cxa_allocate_exception

   822 

   823   ucbp->exception_cleanup = external_exception_termination;

   824   ep->exceptionType = t;

   825   ep->exceptionDestructor = d;

   826   ep->propagationCount = 1;      // Propagating by 1 throw

   827 

   828   // Increment the uncaught C++ exceptions count

   829 

   830   __cxa_eh_globals *g = __cxa_get_globals();

   831   g->uncaughtExceptions++;

   832 

   833   // Tell debugger what's happening

   834 

   835   DEBUGGER_BOTTLENECK(ucbp, _UASUBSYS_CPP, _UAACT_STARTING, t);

   836 

   837   // Initiate unwinding - if we get control back, call C++ routine terminate()

   838 

   839   _Unwind_RaiseException(ucbp);

   840 

   841 #ifdef CPP_DIAGNOSTICS

   842   printf("__cxa_throw: throw failed\n");

   843 #endif

   844 

   845   __cxa_call_terminate(ucbp);

   846 }

   847 

   848 #pragma pop

   849 

   850 /* ----- Type matching: ----- */

   851 

   852 /* This is located here so that (in ARM's implementation) it is only retained in

   853  * an image if the application itself throws.

   854  */

   855 

   856 /* Type matching functions.

   857  * C++ DR126 says the matching rules for fnspecs are intended to be the same as

   858  * those for catch:

   859  * "A function is said to allow an exception of type E if its exception-specification

   860  * contains a type T for which a handler of type T would be a match (15.3 except.handle)

   861  * for an exception of type E."

   862  * Thus we have a single type matching rule.

   863  */

   864 

   865 /* Helper macros: */

   866 

   867 #define CV_quals_of_pointee(P) (((const abi::__pbase_type_info *)(P))->__flags & \

   868 		                (abi::__pbase_type_info::__const_mask | \

   869 		                 abi::__pbase_type_info::__volatile_mask))

   870 

   871 #define is_const(QUALS) (((QUALS) & abi::__pbase_type_info::__const_mask) != 0)

   872 

   873 #define any_qualifier_missing(TEST_QUALS, REF_QUALS) ((~(TEST_QUALS) & (REF_QUALS)) != 0)

   874 

   875 /* A routine is required for derived class to base class conversion.

   876  * This is obtained via a macro definition DERIVED_TO_BASE_CONVERSION

   877  * in unwind_env.h.

   878  */

   879 

   880 /* External entry point:

   881  * Type check the c++ rtti object for compatibility against the type of

   882  * the object containing the ucb. Return a pointer to the matched object

   883  * (possibly a non-leftmost baseclass of the exception object)

   884  */

   885 EXPORT_C __cxa_type_match_result __cxa_type_match(UCB *ucbp, const type_info *match_type,

   886                                                   bool is_reference_type, void **matched_objectpp)

   887 {

   888   if (NAMES::is_foreign_exception(ucbp))

   889     return ctm_failed;

   890 

   891   __cxa_exception *ep = ucbp_to_ep(ucbp);

   892   const type_info *throw_type = ep->exceptionType;

   893   bool previous_qualifiers_include_const = true; // for pointer qualification conversion

   894   unsigned int pointer_depth = 0;

   895   void *original_objectp = ep + 1;

   896   void *current_objectp = original_objectp;

   897 

   898   for (;;) {

   899 

   900     // Match if identical

   901 

   902     if (*throw_type == *match_type) {

   903       *matched_objectpp = original_objectp;

   904 #ifdef CPP_DIAGNOSTICS

   905       printf("__cxa_type_match: success\n");

   906 #endif

   907       return ctm_succeeded;

   908     }

   909 

   910     // Fail if one is a pointer and the other isn't

   911 

   912     const type_info &type_throw_type = typeid(*throw_type);

   913     const type_info &type_match_type = typeid(*match_type);

   914 

   915     if ((type_throw_type == typeid(abi::__pointer_type_info) ||

   916 	 type_match_type == typeid(abi::__pointer_type_info)) &&

   917 	type_throw_type != type_match_type) {

   918 #ifdef CPP_DIAGNOSTICS

   919       printf("__cxa_type_match: failed (mixed ptr/non-ptr)\n");

   920 #endif

   921       return ctm_failed;

   922     }

   923 

   924     // Both are pointers or neither is

   925     if (type_throw_type == typeid(abi::__pointer_type_info)) {

   926       // Both are pointers

   927 #ifdef CPP_DIAGNOSTICS

   928       printf("__cxa_type_match: throwing a ptr\n");

   929 #endif

   930       pointer_depth++;

   931       // Check match_type is at least as CV-qualified as throw_type

   932       unsigned int match_quals = CV_quals_of_pointee(match_type);

   933       unsigned int throw_quals = CV_quals_of_pointee(throw_type);

   934       if (any_qualifier_missing(match_quals, throw_quals)) {

   935 #ifdef CPP_DIAGNOSTICS

   936 	printf("__cxa_type_match: failed (missing qualifiers)\n");

   937 #endif

   938 	return ctm_failed;

   939       }

   940       // If the match type has additional qualifiers not found in the

   941       // throw type, any previous qualifiers must have included const

   942       if (any_qualifier_missing(throw_quals, match_quals) &&

   943 	  !previous_qualifiers_include_const) {

   944 #ifdef CPP_DIAGNOSTICS

   945 	printf("__cxa_type_match: failed (not all qualifiers have const)\n");

   946 #endif

   947 	return ctm_failed;

   948       }

   949       if (!is_const(match_quals))

   950 	previous_qualifiers_include_const = false;

   951       throw_type = ((const abi::__pbase_type_info *)throw_type)->__pointee;

   952       match_type = ((const abi::__pbase_type_info *)match_type)->__pointee;

   953       if (current_objectp != NULL)

   954         current_objectp = *(void **)current_objectp;

   955       continue;

   956     }

   957 

   958     // Neither is a pointer now but qualification conversion has been done.

   959     // See if pointer conversion on the original was possible.

   960     // T* will match void*

   961 

   962     if (pointer_depth == 1 && *match_type == typeid(void)) {

   963       if (is_reference_type) {

   964 #ifdef CPP_DIAGNOSTICS

   965         printf("__cxa_type_match: failed (void *&)\n");

   966 #endif

   967         return ctm_failed;

   968       } else {

   969         *matched_objectpp = original_objectp;

   970 #ifdef CPP_DIAGNOSTICS

   971         printf("__cxa_type_match: success (conversion to void *)\n");

   972 #endif

   973         return ctm_succeeded;

   974       }

   975     }

   976 

   977     // Else if we have 2 (different) class types, a derived class is matched by a

   978     // non-ambiguous public base class (perhaps not a leftmost one) and a

   979     // pointer to a derived class is matched by a non-reference pointer to

   980     // non-ambiguous public base class (perhaps not a leftmost one).

   981     // __si_class_type_info and __vmi_class_type_info are classes with bases.

   982 

   983     void *matched_base_p;

   984 

   985     if ((pointer_depth == 0 || (pointer_depth == 1 && !is_reference_type)) &&

   986 	(type_throw_type == typeid(abi::__si_class_type_info) ||

   987 	 type_throw_type == typeid(abi::__vmi_class_type_info))) {

   988       if (DERIVED_TO_BASE_CONVERSION(current_objectp, &matched_base_p,

   989 				     throw_type, match_type)) {

   990 #ifdef CPP_DIAGNOSTICS

   991 	printf("__cxa_type_match: success (matched base 0x%x of 0x%x%s, thrown object 0x%x)\n",

   992 	       matched_base_p, current_objectp,

   993 	       pointer_depth == 0 ? "" : " via ptr",

   994 	       original_objectp);

   995 #endif

   996         *matched_objectpp = matched_base_p;

   997         return pointer_depth == 0 ? ctm_succeeded : ctm_succeeded_with_ptr_to_base;

   998       } else {

   999 #ifdef CPP_DIAGNOSTICS

  1000 	printf("__cxa_type_match: failed (derived to base failed or ref to base pointer)\n");

  1001 #endif

  1002 	return ctm_failed;

  1003       }

  1004     }

  1005 

  1006 #ifdef CPP_DIAGNOSTICS

  1007     printf("__cxa_type_match: failed (types simply differ)\n");

  1008 #endif

  1009     return ctm_failed;

  1010   } /* for */

  1011 }

  1012 

  1013 

  1014 /* For debugging purposes: */

  1015 #ifdef DEBUG

  1016 extern "C" bool debug__cxa_type_match(void *objptr,

  1017 				      const type_info *throw_type,

  1018 				      const type_info *catch_type,

  1019 				      void **matched_objectpp)

  1020 {

  1021   /* Create enough of an exception object that the type-matcher can run, then

  1022    * check the type. Objptr is expected to be the result of a call to

  1023    * __cxa_allocate_exception, which has then been copy-constructed.

  1024    */

  1025   __cxa_exception *e = ((__cxa_exception *)objptr) - 1;

  1026   e->exceptionType = throw_type;

  1027   return __cxa_type_match(&e->ucb, catch_type, false, matched_objectpp);

  1028 }

  1029 #endif

  1030 

  1031 

  1032 #endif /* arm_exceptions_throw_c */

  1033 #ifdef arm_exceptions_rethrow_c

  1034 

  1035 /* Redeclare _Unwind_RaiseException as weak (if WEAKDECL is defined

  1036  * appropriately) so the use from __cxa_rethrow does not on its own

  1037  * force the unwind library to be loaded.

  1038  */

  1039 

  1040 extern "C" WEAKDECL _Unwind_Reason_Code _Unwind_RaiseException(UCB *ucbp);

  1041 

  1042 #pragma exceptions_unwind

  1043 

  1044 EXPORT_C void __cxa_rethrow(void)

  1045 {

  1046   // Recover the exception object - it is the most recent caught exception object

  1047   __cxa_eh_globals *g = __cxa_get_globals();

  1048   __cxa_exception *ep = g->caughtExceptions;

  1049   bool foreign;

  1050 

  1051   // Must call terminate here if no such exception

  1052   if (ep == NULL) NAMES::call_terminate_handler(NULL);

  1053 

  1054   UCB *ucbp = &ep->ucb;

  1055 

  1056   // Mark the object as being propagated by throw, preventing multiple

  1057   // propagation and also permitting __cxa_end_catch to do the right

  1058   // thing when it is called from the handler's cleanup.

  1059 

  1060   ep->propagationCount++;

  1061 

  1062   // Now reraise, taking care with foreign exceptions

  1063 

  1064   foreign = NAMES::is_foreign_exception(ucbp);

  1065   if (foreign) {

  1066     // Indirect through the intermediate object to the foreign ucb

  1067     ucbp = (UCB *)ep->exceptionType;

  1068   } else {

  1069     // Increment the uncaught C++ exceptions count

  1070     g->uncaughtExceptions++;

  1071   }

  1072 

  1073   // Tell debugger what's happening

  1074 

  1075   DEBUGGER_BOTTLENECK(ucbp, _UASUBSYS_CPP, _UAACT_STARTING, foreign ? NULL : ep->exceptionType);

  1076 

  1077   // Initiate unwinding - if we get control back, call C++ routine terminate()

  1078 

  1079   _Unwind_RaiseException(ucbp);

  1080 

  1081 #ifdef CPP_DIAGNOSTICS

  1082   printf("__cxa_rethrow: throw failed\n");

  1083 #endif

  1084 

  1085   __cxa_call_terminate(ucbp);

  1086 }

  1087 

  1088 #endif /* arm_exceptions_rethrow_c */

  1089 #ifdef arm_exceptions_foreign_c

  1090 

  1091 /* During catch and cleanup, foreign exception objects are dealt with using

  1092  * an intermediate __cxa_exception block in the appropriate exceptions

  1093  * chain. This block has the same exception_class as the real foreign

  1094  * ucb, and points to the real ucb via the intermediate block's exceptionType

  1095  * field. This helper function checks whether it has been passed such an

  1096  * intermediate block and sets one up if not. Only call it when the UCB

  1097  * is known to belong to a foreign exception.

  1098  */

  1099 

  1100 __cxa_exception *NAMES::get_foreign_intermediary(__cxa_exception *head_ep, UCB *ucbp)

  1101 {

  1102   if (head_ep != NULL) {

  1103     UCB *head_ucbp = &head_ep->ucb;

  1104     if (NAMES::same_exceptions_class(&head_ucbp->exception_class, &ucbp->exception_class) &&

  1105 	(UCB *)head_ep->exceptionType == ucbp)

  1106       return head_ep;

  1107   }

  1108 

  1109   // Create an intermediate block. Only initialise as much as necessary

  1110   __cxa_exception *ep = ((__cxa_exception *)__cxa_allocate_exception(0)) - 1;

  1111   UCB *new_ucbp = &ep->ucb;

  1112   memcpy(new_ucbp->exception_class, ucbp->exception_class, EXCEPTIONS_CLASS_SIZE);

  1113   ep->propagationCount = 0;                     // Not propagating

  1114   ep->handlerCount = 0;                         // Not handled

  1115   ep->nextCaughtException = NULL;               // Not in chain

  1116   ep->exceptionType = (const type_info *)ucbp;  // The foreign UCB

  1117   return ep;

  1118 }

  1119 

  1120 

  1121 #endif /* arm_exceptions_foreign_c */

  1122 #ifdef arm_exceptions_cleanup_c

  1123 

  1124 EXPORT_C bool __cxa_begin_cleanup(UCB *ucbp)

  1125 {

  1126   // Indicate that a cleanup is about to start.

  1127   // Save the exception pointer over the cleanup for recovery later, using a chain.

  1128   // If we allowed the exception to be rethrown in a cleanup, then

  1129   // the object might appear multiple times at the head of this chain,

  1130   // and the propagationCount could be used to track this - at this point,

  1131   // the object is logically in the chain propagationCount-1 times, and

  1132   // physically 0 or 1 times. Thus if propagationCount == 1 we should insert

  1133   // it physically. A similar rule is used for physical removal in

  1134   //__cxa_end_cleanup.

  1135   // Foreign exceptions are handled via an intermediate __cxa_exception object