Exception Handling ABI for the ARM Architecture

Exception handling ABI for the ARM architecture
12 APPENDIX B: EXAMPLE C++ LANGUAGE IMPLEMENTATION
This section is for illustration only and the actual ARM implementation may deviate without notice from the details
presented here.
12.1 Exception Control Object
At the time of writing, the following structure is used by the ARM C++ implementation.
struct __cxa_exception {
const std::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
_Unwind_Control_Block ucb;
// Forces alignment of next item to 8-byte boundary
};
A complete C++ exception object consists of a __cxa_exception followed by the C++ exception object (EO) itself.
Type __cxa_exception includes the LEO members required for housekeeping by the C++ implementation, and the
unwinding control block (UCB—see §7.2).
12.2 Per-thread global memory
The __cxa_eh_globals structure records the per-thread handlers set by std::set_terminate() and
std::set_unexpected(), and contains other fields needed by the implementation.
typedef void (*handler)(void);
typedef void (*terminate_handler)(void);
typedef void (*unexpected_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 for terminate/unexpected call hook
__cxa_exception *caughtExceptions;
// chain of "caught" exceptions
__cxa_exception *propagatingExceptions; // chain of "propagating"(in cleanup) exceptions
void *emergency_buffer;
// for when rest of heap full
};
__cxa_eh_globals contains the following fields:
uncaughtExceptions is a count of C++ exceptions which are active but not in the caught state (in the technical
meaning of the C++ Standard).
UnexpectedHandler and terminateHandler are the current (per-thread) handlers set by std::set_unexpected()
and std::set_terminate() respectively.
implementation_ever_called_terminate is true if the unwind mechanism ever called terminate(). We believe
this is required for correct implementation of std::uncaught_exception(). See §11 for a lengthy discussion).
call_hook is set by the implementation to the handler it wants std::terminate() or std::unexpected() to call.
ARM IHI 0038A Copyright © 2002-2005, 2007 ARM Limited. All rights reserved. Page 48 of 50