URL
https://opencores.org/ocsvn/openrisc/openrisc/trunk
Subversion Repositories openrisc
[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libstdc++-v3/] [libsupc++/] [eh_call.cc] - Rev 781
Go to most recent revision | Compare with Previous | Blame | View Log
// -*- C++ -*- Helpers for calling unextected and terminate // Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, // 2011 // 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 <bits/c++config.h> #include <cstdlib> #include <bits/exception_defines.h> #include "unwind-cxx.h" using namespace __cxxabiv1; #include "unwind-pe.h" // Helper routine for when the exception handling code needs to call // terminate. extern "C" void __cxa_call_terminate(_Unwind_Exception* ue_header) throw () { if (ue_header) { // terminate is classed as a catch handler. __cxa_begin_catch(ue_header); // Call the terminate handler that was in effect when we threw this // exception. */ if (__is_gxx_exception_class(ue_header->exception_class)) { __cxa_exception* xh; xh = __get_exception_header_from_ue(ue_header); __terminate(xh->terminateHandler); } } /* Call the global routine if we don't have anything better. */ std::terminate(); } #ifdef __ARM_EABI_UNWINDER__ // The ARM EABI __cxa_call_unexpected has the same semantics as the generic // routine, but the exception specification has a different format. extern "C" void __cxa_call_unexpected(void* exc_obj_in) { _Unwind_Exception* exc_obj = reinterpret_cast<_Unwind_Exception*>(exc_obj_in); int rtti_count = 0; _Unwind_Word rtti_stride = 0; _Unwind_Word* rtti_list = NULL; _Unwind_Ptr rtti_base = 0; bool foreign_exception; std::unexpected_handler unexpectedHandler = NULL; std::terminate_handler terminateHandler = NULL; __cxa_exception* xh; if (__is_gxx_exception_class(exc_obj->exception_class)) { // Save data from the EO, which may be clobbered by _cxa_begin_catch. xh = __get_exception_header_from_ue(exc_obj); unexpectedHandler = xh->unexpectedHandler; terminateHandler = xh->terminateHandler; rtti_count = exc_obj->barrier_cache.bitpattern[1]; rtti_base = (_Unwind_Ptr) exc_obj->barrier_cache.bitpattern[2]; rtti_stride = exc_obj->barrier_cache.bitpattern[3]; rtti_list = (_Unwind_Word*) exc_obj->barrier_cache.bitpattern[4]; foreign_exception = false; } else foreign_exception = true; /* This must be called after extracting data from the EO, but before calling unexpected(). */ __cxa_begin_catch(exc_obj); // This function is a handler for our exception argument. If we exit // by throwing a different exception, we'll need the original cleaned up. struct end_catch_protect { end_catch_protect() { } ~end_catch_protect() { __cxa_end_catch(); } } end_catch_protect_obj; __try { if (foreign_exception) std::unexpected(); else __unexpected(unexpectedHandler); } __catch(...) { /* See if the new exception matches the rtti list. */ if (foreign_exception) std::terminate(); // Get the exception thrown from unexpected. __cxa_eh_globals* globals = __cxa_get_globals_fast(); __cxa_exception* new_xh = globals->caughtExceptions; void* new_ptr = __get_object_from_ambiguous_exception (new_xh); const std::type_info* catch_type; int n; bool bad_exception_allowed = false; const std::type_info& bad_exc = typeid(std::bad_exception); // Check the new exception against the rtti list for (n = 0; n < rtti_count; n++) { _Unwind_Word offset; offset = (_Unwind_Word) &rtti_list[n * (rtti_stride >> 2)]; offset = _Unwind_decode_typeinfo_ptr(rtti_base, offset); catch_type = (const std::type_info*) (offset); if (__cxa_type_match(&new_xh->unwindHeader, catch_type, false, &new_ptr) != ctm_failed) __throw_exception_again; if (catch_type->__do_catch(&bad_exc, 0, 1)) bad_exception_allowed = true; } // If the exception spec allows std::bad_exception, throw that. #ifdef __EXCEPTIONS if (bad_exception_allowed) throw std::bad_exception(); #endif // Otherwise, die. __terminate(terminateHandler); } } #endif // __ARM_EABI_UNWINDER__
Go to most recent revision | Compare with Previous | Blame | View Log