URL
https://opencores.org/ocsvn/openrisc/openrisc/trunk
Subversion Repositories openrisc
[/] [openrisc/] [tags/] [gnu-dev/] [fsf-gcc-snapshot-1-mar-12/] [or1k-gcc/] [libstdc++-v3/] [libsupc++/] [eh_tm.cc] - Rev 742
Go to most recent revision | Compare with Previous | Blame | View Log
// -*- C++ -*- Exception handling routines for Transactional Memory. // Copyright (C) 2009, 2011, 2012 Free Software Foundation, Inc. // // This file is part of GCC. // // GCC is free software; you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation; either version 3, or (at your option) // any later version. // // GCC is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // Under Section 7 of GPL version 3, you are granted additional // permissions described in the GCC Runtime Library Exception, version // 3.1, as published by the Free Software Foundation. // You should have received a copy of the GNU General Public License and // a copy of the GCC Runtime Library Exception along with this program; // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see // <http://www.gnu.org/licenses/>. #include <cstdlib> #include "unwind-cxx.h" using namespace __cxxabiv1; // Free one C++ exception. static void free_any_cxa_exception (_Unwind_Exception *eo) { __cxa_refcounted_exception *h = __get_refcounted_exception_header_from_ue (eo); if (__is_dependent_exception (eo->exception_class)) { __cxa_dependent_exception *dep = __get_dependent_exception_from_ue (eo); h = __get_refcounted_exception_header_from_obj (dep->primaryException); __cxa_free_dependent_exception (dep); } #if __GCC_ATOMIC_INT_LOCK_FREE > 1 if (__atomic_sub_fetch (&h->referenceCount, 1, __ATOMIC_ACQ_REL) == 0) #endif __cxa_free_exception (h + 1); } // Cleanup exception handling state while rolling back state for // a software transactional memory transaction. // // UNTHROWN_OBJ is non-null if we've called __cxa_allocate_exception // but not yet called __cxa_throw for it. // // CLEANUP_EXC is non-null if we're currently processing a cleanup // along an exception path, but we've not caught the exception yet. // // CAUGHT_COUNT is the nesting depth of __cxa_begin_catch within // the transaction; undo as if calling __cxa_end_catch that many times. extern "C" void __cxxabiv1::__cxa_tm_cleanup (void *unthrown_obj, void *cleanup_exc, unsigned int caught_count) throw() { __cxa_eh_globals *globals = __cxa_get_globals_fast (); // Handle a C++ exception not yet thrown. if (unthrown_obj) { globals->uncaughtExceptions -= 1; __cxa_free_exception (unthrown_obj); } // Handle an exception not yet caught ie. processing a cleanup // in between the throw and the catch. if (cleanup_exc) { _Unwind_Exception *eo = reinterpret_cast <_Unwind_Exception *>(cleanup_exc); if (__is_gxx_exception_class (eo->exception_class)) free_any_cxa_exception (eo); else _Unwind_DeleteException (eo); } // Do __cxa_end_catch caught_count times, but don't bother running // the destructors for the objects involved. All of that is being // undone by the transaction restart. if (caught_count > 0) { __cxa_exception *h = globals->caughtExceptions; // Rethrown foreign exceptions are removed from the stack immediately. // We would have freed this exception via THIS_EXC above. if (h == NULL) return; do { __cxa_exception *next; _Unwind_Exception *eo = &h->unwindHeader; if (__is_gxx_exception_class (eo->exception_class)) { next = h->nextException; free_any_cxa_exception (eo); } else { _Unwind_DeleteException (eo); next = 0; } h = next; } while (--caught_count); globals->caughtExceptions = h; } }
Go to most recent revision | Compare with Previous | Blame | View Log