Effects: Allocates memory to hold the exception to be thrown.
thrown_size is the size of the exception object. Can allocate
additional memory to hold private data. If memory can not be allocated, call
std::terminate().

Returns: A pointer to the memory allocated for the exception object.

✓

✓

✓

void __cxa_free_exception(void * thrown_exception) throw();

Effects: Frees memory allocated by __cxa_allocate_exception.

✓

✓

✓

void* __cxa_allocate_dependent_exception() throw();

Effects: Allocates memory to hold a "dependent" exception to be thrown.
thrown_size is the size of the exception object. Can allocate
additional memory to hold private data. If memory can not be allocated, call
std::terminate().

Returns: The adjusted pointer to the exception object. (The adjusted
pointer is typically computed by the personality routine during phase 1 and
saved in the exception object.)

✓

✓

✓

void* __cxa_begin_catch(void* exceptionObject) throw();

Effects:

Increment's the exception's handler count.

Places the exception on the stack of currently-caught exceptions if it is
not already there, linking the exception to the previous top of the stack.

Decrements the uncaught_exception count.

If the initialization of the catch parameter is trivial (e,g., there is no
formal catch parameter, or the parameter has no copy constructor), the calls to
__cxa_get_exception_ptr() and __cxa_begin_catch() may be
combined into a single call to __cxa_begin_catch().

When the personality routine encounters a termination condition, it will call
__cxa_begin_catch() to mark the exception as handled and then call
terminate(), which shall not return to its caller.

Returns: The adjusted pointer to the exception object.

✓

✓

✓

void __cxa_end_catch();

Effects: Locates the most recently caught exception and decrements its
handler count. Removes the exception from the caughtÓexception stack, if the
handler count goes to zero. Destroys the exception if the handler count goes to
zero, and the exception was not re-thrown by throw. Collaboration between
__cxa_rethrow() and __cxa_end_catch() is necessary to handle the last point.
Though implementation-defined, one possibility is for __cxa_rethrow() to set a
flag in the handlerCount member of the exception header to mark an exception
being rethrown.

✓

✓

✓

std::type_info* __cxa_current_exception_type();

Returns: the type of the currently handled exception, or null if there
are no caught exceptions.

✓

✓

✓

void __cxa_rethrow();

Effects: Marks the exception object on top of the caughtExceptions stack
(in an implementation-defined way) as being rethrown. If the caughtExceptions
stack is empty, it calls terminate() (see [C++FDIS] [except.throw], 15.1.8). It
then returns to the handler that called it, which must call __cxa_end_catch(),
perform any necessary cleanup, and finally call _Unwind_Resume() to continue
unwinding.

✓

✓

✓

void* __cxa_current_primary_exception() throw();

Effects: Increments the ownership count of the currently handled
exception (if any) by one.

Returns: the type of the currently handled exception, or null if there
are no caught exceptions.

Effects: This function is called before initialization takes place. If
this function returns 1, either __cxa_guard_release or
__cxa_guard_abort must be called with the same argument. The first
byte of the guard_object is not modified by this function.

On Darwin the implementation checks for deadlock.

Returns: 1 if the initialization is not yet complete, otherwise 0.

✓

✓

✓

void __cxa_guard_release(uint64_t*);

Effects: Sets the first byte of the guard object to a non-zero value.
This function is called after initialization is complete. A thread-safe
implementation will release the mutex acquired by __cxa_guard_acquire after
setting the first byte of the guard object.

✓

✓

✓

void __cxa_guard_abort(uint64_t*);

Effects: This function is called if the initialization terminates by
throwing an exception.