eh_call.cc revision 1.1.1.1
1// -*- C++ -*- Helpers for calling unextected and terminate 2// Copyright (C) 2001, 2002, 2003 Free Software Foundation, Inc. 3// 4// This file is part of GCC. 5// 6// GCC is free software; you can redistribute it and/or modify 7// it under the terms of the GNU General Public License as published by 8// the Free Software Foundation; either version 2, or (at your option) 9// any later version. 10// 11// GCC is distributed in the hope that it will be useful, 12// but WITHOUT ANY WARRANTY; without even the implied warranty of 13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14// GNU General Public License for more details. 15// 16// You should have received a copy of the GNU General Public License 17// along with GCC; see the file COPYING. If not, write to 18// the Free Software Foundation, 51 Franklin Street, Fifth Floor, 19// Boston, MA 02110-1301, USA. 20 21// As a special exception, you may use this file as part of a free software 22// library without restriction. Specifically, if other files instantiate 23// templates or use macros or inline functions from this file, or you compile 24// this file and link it with other files to produce an executable, this 25// file does not by itself cause the resulting executable to be covered by 26// the GNU General Public License. This exception does not however 27// invalidate any other reasons why the executable file might be covered by 28// the GNU General Public License. 29 30#include <bits/c++config.h> 31#include <cstdlib> 32#include <exception_defines.h> 33#include "unwind-cxx.h" 34 35using namespace __cxxabiv1; 36 37#include "unwind-pe.h" 38 39 40// Helper routine for when the exception handling code needs to call 41// terminate. 42 43extern "C" void 44__cxa_call_terminate(_Unwind_Exception* ue_header) 45{ 46 47 if (ue_header) 48 { 49 // terminate is classed as a catch handler. 50 __cxa_begin_catch(ue_header); 51 52 // Call the terminate handler that was in effect when we threw this 53 // exception. */ 54 if (__is_gxx_exception_class(ue_header->exception_class)) 55 { 56 __cxa_exception* xh; 57 58 xh = __get_exception_header_from_ue(ue_header); 59 __terminate(xh->terminateHandler); 60 } 61 } 62 /* Call the global routine if we don't have anything better. */ 63 std::terminate(); 64} 65 66 67#ifdef __ARM_EABI_UNWINDER__ 68// The ARM EABI __cxa_call_unexpected has the same semantics as the generic 69// routine, but the exception specification has a different format. 70extern "C" void 71__cxa_call_unexpected(void* exc_obj_in) 72{ 73 _Unwind_Exception* exc_obj 74 = reinterpret_cast<_Unwind_Exception*>(exc_obj_in); 75 76 int rtti_count = 0; 77 _Unwind_Word rtti_stride = 0; 78 _Unwind_Word* rtti_list = NULL; 79 bool foreign_exception; 80 std::unexpected_handler unexpectedHandler = NULL; 81 std::terminate_handler terminateHandler = NULL; 82 __cxa_exception* xh; 83 if (__is_gxx_exception_class(exc_obj->exception_class)) 84 { 85 // Save data from the EO, which may be clobbered by _cxa_begin_catch. 86 xh = __get_exception_header_from_ue(exc_obj); 87 unexpectedHandler = xh->unexpectedHandler; 88 terminateHandler = xh->terminateHandler; 89 rtti_count = exc_obj->barrier_cache.bitpattern[1]; 90 91 rtti_stride = exc_obj->barrier_cache.bitpattern[3]; 92 rtti_list = (_Unwind_Word*) exc_obj->barrier_cache.bitpattern[4]; 93 foreign_exception = false; 94 } 95 else 96 foreign_exception = true; 97 98 /* This must be called after extracting data from the EO, but before 99 calling unexpected(). */ 100 __cxa_begin_catch(exc_obj); 101 102 // This function is a handler for our exception argument. If we exit 103 // by throwing a different exception, we'll need the original cleaned up. 104 struct end_catch_protect 105 { 106 end_catch_protect() { } 107 ~end_catch_protect() { __cxa_end_catch(); } 108 } end_catch_protect_obj; 109 110 111 try 112 { 113 if (foreign_exception) 114 std::unexpected(); 115 else 116 __unexpected(unexpectedHandler); 117 } 118 catch(...) 119 { 120 /* See if the new exception matches the rtti list. */ 121 if (foreign_exception) 122 std::terminate(); 123 124 // Get the exception thrown from unexpected. 125 126 __cxa_eh_globals* globals = __cxa_get_globals_fast(); 127 __cxa_exception* new_xh = globals->caughtExceptions; 128 void* new_ptr = new_xh + 1; 129 const std::type_info* catch_type; 130 int n; 131 bool bad_exception_allowed = false; 132 const std::type_info& bad_exc = typeid(std::bad_exception); 133 134 // Check the new exception against the rtti list 135 for (n = 0; n < rtti_count; n++) 136 { 137 _Unwind_Word offset; 138 139 offset = (_Unwind_Word) &rtti_list[n * (rtti_stride >> 2)]; 140 offset = _Unwind_decode_target2(offset); 141 catch_type = (const std::type_info*) (offset); 142 143 if (__cxa_type_match(&new_xh->unwindHeader, catch_type, false, 144 &new_ptr) != ctm_failed) 145 __throw_exception_again; 146 147 if (catch_type->__do_catch(&bad_exc, 0, 1)) 148 bad_exception_allowed = true; 149 } 150 151 // If the exception spec allows std::bad_exception, throw that. 152#ifdef __EXCEPTIONS 153 if (bad_exception_allowed) 154 throw std::bad_exception(); 155#endif 156 157 // Otherwise, die. 158 __terminate(terminateHandler); 159 } 160} 161#endif // __ARM_EABI_UNWINDER__ 162