using namespace GTM;
+/* Exceptions can exist in three phases: (1) after having been allocated by
+ __cxa_allocate_exception but before being handed off to __cxa_throw,
+ (2) when they are in flight, so between __cxa_throw and __cxa_begin_catch,
+ and (3) when they are being handled (between __cxa_begin_catch and
+ __cxa_end_catch). Note that when an exception is re-thrown in (3), it is
+ not moving back to (2) but handled as a special case of (3) by the EH
+ runtime.
+
+ We can get aborts in all three phases, for example in (1) during
+ construction of the exception object, or in (2) in destructors called
+ while unwinding the stack. The transaction that created an exception
+ object can only commit in phase (3) by re-throwing the exception; it cannot
+ commit in other phases because throw expressions and catch clauses are
+ properly nested wrt transactions and because the compiler wraps
+ transaction bodies in a try/catch-all construct.
+
+ We handle phase (1) by dealing with exception objects similar to how we
+ deal with other (de)allocations, which also ensures that we can have more
+ than one exception object allocated at the same time (e.g., if the
+ throw expression itself throws an exception and thus calls
+ __cxa_allocate_exception). However, on the call to __cxa_begin_catch
+ we hand off the exception to the special handling of phase (3) and
+ remove the undo log entry of the allocation. Note that if the allocation
+ happened outside of this transaction, we do not need to do anything.
+
+ When an exception reaches phase (2) due to a call to __cxa_throw, the count
+ of uncaught exceptions is incremented. We roll back this effect by saving
+ and restoring this number in the structure returned from __cxa_get_globals.
+ This also takes care of increments of this count when re-throwing an
+ exception.
+
+ For phase (3), we keep track of the number of times __cxa_begin_catch
+ has been called without a matching call to __cxa_end_catch. This count
+ is then used by __cxa_tm_cleanup to roll back the exception handling state
+ by calling __cxa_end_catch for the exceptions that have not been finished
+ yet (without running destructors though because we roll back the memory
+ anyway).
+ Once an exception that was allocated in this transaction enters phase (3),
+ it does not need to be deallocated on abort anymore because the calls to
+ __cxa_end_catch will take care of that.
+
+ We require all code executed by the transaction to be transaction_safe (or
+ transaction_pure, or to have wrappers) if the transaction is to be rolled
+ back. However, we take care to not require this for transactions that
+ just commit; this way, transactions that enter serial mode and then call
+ uninstrumented code continue to work.
+ */
+
/* Everything from libstdc++ is weak, to avoid requiring that library
to be linked into plain C applications using libitm.so. */
extern "C" {
+struct __cxa_eh_globals
+{
+ void * caughtExceptions;
+ unsigned int uncaughtExceptions;
+};
+
extern void *__cxa_allocate_exception (size_t) WEAK;
+extern void __cxa_free_exception (void *) WEAK;
extern void __cxa_throw (void *, void *, void *) WEAK;
extern void *__cxa_begin_catch (void *) WEAK;
extern void __cxa_end_catch (void) WEAK;
extern void __cxa_tm_cleanup (void *, void *, unsigned int) WEAK;
+extern __cxa_eh_globals *__cxa_get_globals (void) WEAK;
#if !defined (HAVE_ELF_STYLE_WEAKREF)
void *__cxa_allocate_exception (size_t) { return NULL; }
+void __cxa_free_exception (void *) { return; }
void __cxa_throw (void *, void *, void *) { return; }
void *__cxa_begin_catch (void *) { return NULL; }
void __cxa_end_catch (void) { return; }
void __cxa_tm_cleanup (void *, void *, unsigned int) { return; }
void _Unwind_DeleteException (_Unwind_Exception *) { return; }
+__cxa_eh_globals *__cxa_get_globals (void) { return NULL; }
#endif /* HAVE_ELF_STYLE_WEAKREF */
}
+static void
+free_any_exception (void *exc_ptr)
+{
+ // The exception could be in phase (2) and thus calling just
+ // _cxa_free_exception might not be sufficient.
+ __cxa_tm_cleanup (NULL, exc_ptr, 0);
+}
void *
_ITM_cxa_allocate_exception (size_t size)
{
void *r = __cxa_allocate_exception (size);
- gtm_thr()->cxa_unthrown = r;
+ gtm_thr()->record_allocation (r, free_any_exception);
return r;
}
void
+_ITM_cxa_free_exception (void *exc_ptr)
+{
+ // __cxa_free_exception can be called from user code directly if
+ // construction of an exception object throws another exception, in which
+ // case we need to roll back the initial exception. We handle this similar
+ // to dead allocations in that we deallocate the exception on both commit
+ // and abort of an outermost transaction.
+ gtm_thr()->forget_allocation (exc_ptr, free_any_exception);
+}
+
+void
_ITM_cxa_throw (void *obj, void *tinfo, void *dest)
{
- gtm_thr()->cxa_unthrown = NULL;
+ // This used to be instrumented, but does not need to be anymore.
__cxa_throw (obj, tinfo, dest);
}
void *
_ITM_cxa_begin_catch (void *exc_ptr)
{
- gtm_thr()->cxa_catch_count++;
+ // If this exception object has been allocated by this transaction, we
+ // discard the undo log entry for the allocation; we are entering phase (3)
+ // now and will handle this exception specially.
+ // Note that this exception cannot have been allocated in a parent
+ // transaction or enclosing nontransactional block because an atomic block
+ // cannot contain just a catch clause but not the associated try clause.
+ // The exception can have been allocated in a nested transaction, in which
+ // case the commit of the nested transaction will have inserted the undo
+ // log entry of the allocation in our undo log.
+ // The exception can also have been allocated in a nested nontransactional
+ // block, but then this transaction cannot abort anymore; functions that
+ // are marked transaction_pure, for example, must not side-step the
+ // transactional exception handling we implement here.
+ gtm_thread *t = gtm_thr ();
+ t->discard_allocation (exc_ptr);
+ // Keep track of the number of unfinished catch handlers.
+ t->cxa_catch_count++;
return __cxa_begin_catch (exc_ptr);
}
void
_ITM_cxa_end_catch (void)
{
+ // Keep track of the number of unfinished catch handlers.
gtm_thr()->cxa_catch_count--;
__cxa_end_catch ();
}
void
+GTM::gtm_thread::init_cpp_exceptions ()
+{
+ // Only save and restore the number of uncaught exceptions if this is
+ // actually used in the program.
+ if (__cxa_get_globals != NULL && __cxa_get_globals () != 0)
+ cxa_uncaught_count_ptr = &__cxa_get_globals ()->uncaughtExceptions;
+ else
+ cxa_uncaught_count_ptr = 0;
+}
+
+void
GTM::gtm_thread::revert_cpp_exceptions (gtm_transaction_cp *cp)
{
if (cp)
{
- // If rolling back a nested transaction, only clean up unthrown
- // exceptions since the last checkpoint. Always reset eh_in_flight
- // because it just contains the argument provided to
- // _ITM_commitTransactionEH
- void *unthrown =
- (cxa_unthrown != cp->cxa_unthrown ? cxa_unthrown : NULL);
+ // If rolling back a nested transaction, only clean up incompletely
+ // caught exceptions since the last checkpoint.
assert (cxa_catch_count >= cp->cxa_catch_count);
uint32_t catch_count = cxa_catch_count - cp->cxa_catch_count;
- if (unthrown || catch_count)
+ if (catch_count)
{
- __cxa_tm_cleanup (unthrown, this->eh_in_flight, catch_count);
+ __cxa_tm_cleanup (NULL, NULL, catch_count);
cxa_catch_count = cp->cxa_catch_count;
- cxa_unthrown = cp->cxa_unthrown;
- this->eh_in_flight = NULL;
}
}
else
{
// Both cxa_catch_count and cxa_unthrown are maximal because EH regions
// and transactions are properly nested.
- if (this->cxa_unthrown || this->cxa_catch_count)
+ if (cxa_catch_count)
{
- __cxa_tm_cleanup (this->cxa_unthrown, this->eh_in_flight,
- this->cxa_catch_count);
- this->cxa_catch_count = 0;
- this->cxa_unthrown = NULL;
- this->eh_in_flight = NULL;
+ __cxa_tm_cleanup (NULL, NULL, cxa_catch_count);
+ cxa_catch_count = 0;
}
}
+ // Reset the number of uncaught exceptions. Any allocations for these
+ // exceptions have been rolled back already, if necessary.
+ if (cxa_uncaught_count_ptr != 0)
+ *cxa_uncaught_count_ptr = cxa_uncaught_count;
+ // Always reset eh_in_flight because it just contains the argument provided
+ // to _ITM_commitTransactionEH.
+ eh_in_flight = NULL;
}
@example
void _ITM_commitTransactionEH(void *exc_ptr) ITM_REGPARM;
void *_ITM_cxa_allocate_exception (size_t);
+void _ITM_cxa_free_exception (void *exc_ptr);
void _ITM_cxa_throw (void *obj, void *tinfo, void *dest);
void *_ITM_cxa_begin_catch (void *exc_ptr);
void _ITM_cxa_end_catch (void);
@end example
-@code{_ITM_commitTransactionEH} must be called to commit a transaction if an
-exception could be in flight at this position in the code. @code{exc_ptr} is
-the current exception or zero if there is no current exception.
+The EH scheme changed in version 6 of GCC. Previously, the compiler
+added a call to @code{_ITM_commitTransactionEH} to commit a transaction if
+an exception could be in flight at this position in the code; @code{exc_ptr} is
+the address of the current exception and must be non-zero. Now, the
+compiler must catch all exceptions that are about to be thrown out of a
+transaction and call @code{_ITM_commitTransactionEH} from the catch clause,
+with @code{exc_ptr} being zero.
+
+Note that the old EH scheme never worked completely in GCC's implementation;
+libitm currently does not try to be compatible with the old scheme.
+
The @code{_ITM_cxa...} functions are transactional wrappers for the respective
@code{__cxa...} functions and must be called instead of these in transactional
-code.
+code. @code{_ITM_cxa_free_exception} is new in GCC 6.
To support this EH scheme, libstdc++ needs to provide one additional function
(@code{_cxa_tm_cleanup}), which is used by the TM to clean up the exception
unsigned int caught_count);
@end example
-@code{unthrown_obj} is non-null if the program called
+Since GCC 6, @code{unthrown_obj} is not used anymore and always null;
+prior to that, @code{unthrown_obj} is non-null if the program called
@code{__cxa_allocate_exception} for this exception but did not yet called
@code{__cxa_throw} for it. @code{cleanup_exc} is non-null if the program is
currently processing a cleanup along an exception path but has not caught this
@code{calloc}, and @code{free}. Within transactions, the compiler should
replace calls to the original functions with calls to the wrapper functions.
+libitm also provides transactional clones of C++ memory management functions
+such as global operator new and delete. They are part of libitm for historic
+reasons but do not need to be part of this ABI.
+
@section [No changes] Future Enhancements to the ABI
projects / platform / upstream / gcc.git / commitdiff