| /* Exception handling and frame unwind runtime interface routines. |
| Copyright (C) 2001 Free Software Foundation, Inc. |
| |
| This file is part of GNU CC. |
| |
| GNU CC 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 2, or (at your option) |
| any later version. |
| |
| GNU CC 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. |
| |
| You should have received a copy of the GNU General Public License |
| along with GNU CC; see the file COPYING. If not, write to |
| the Free Software Foundation, 59 Temple Place - Suite 330, |
| Boston, MA 02111-1307, USA. */ |
| |
| /* This is derived from the C++ ABI for IA-64. Where we diverge |
| for cross-architecture compatibility are noted with "@@@". |
| This file is included from unwind-dw2.c or unwind-ia64.c. */ |
| |
| /* Subroutine of _Unwind_RaiseException also invoked from _Unwind_Resume. |
| |
| Unwind the stack calling the personality routine to find both the |
| exception handler and intermediary cleanup code. We'll only locate |
| the first such frame here. Cleanup code will call back into |
| _Unwind_Resume and we'll continue Phase 2 there. */ |
| |
| static _Unwind_Reason_Code |
| _Unwind_RaiseException_Phase2(struct _Unwind_Exception *exc, |
| struct _Unwind_Context *context) |
| { |
| _Unwind_Reason_Code code; |
| |
| while (1) |
| { |
| _Unwind_FrameState fs; |
| int match_handler; |
| |
| code = uw_frame_state_for (context, &fs); |
| |
| /* Identify when we've reached the designated handler context. */ |
| match_handler = (uw_identify_context (context) == exc->private_2 |
| ? _UA_HANDLER_FRAME : 0); |
| |
| if (code != _URC_NO_REASON) |
| /* Some error encountered. Ususally the unwinder doesn't |
| diagnose these and merely crashes. */ |
| return _URC_FATAL_PHASE2_ERROR; |
| |
| /* Unwind successful. Run the personality routine, if any. */ |
| if (fs.personality) |
| { |
| code = (*fs.personality) (1, _UA_CLEANUP_PHASE | match_handler, |
| exc->exception_class, exc, context); |
| if (code == _URC_INSTALL_CONTEXT) |
| break; |
| if (code != _URC_CONTINUE_UNWIND) |
| return _URC_FATAL_PHASE2_ERROR; |
| } |
| |
| /* Don't let us unwind past the handler context. */ |
| if (match_handler) |
| abort (); |
| |
| uw_update_context (context, &fs); |
| } |
| |
| return code; |
| } |
| |
| |
| /* Raise an exception, passing along the given exception object. */ |
| |
| _Unwind_Reason_Code |
| _Unwind_RaiseException(struct _Unwind_Exception *exc) |
| { |
| struct _Unwind_Context this_context, cur_context; |
| _Unwind_Reason_Code code; |
| |
| uw_init_context (&this_context); |
| cur_context = this_context; |
| |
| /* Phase 1: Search. Unwind the stack, calling the personality routine |
| with the _UA_SEARCH_PHASE flag set. Do not modify the stack yet. */ |
| while (1) |
| { |
| _Unwind_FrameState fs; |
| |
| code = uw_frame_state_for (&cur_context, &fs); |
| |
| if (code == _URC_END_OF_STACK) |
| /* Hit end of stack with no handler found. */ |
| return _URC_END_OF_STACK; |
| |
| if (code != _URC_NO_REASON) |
| /* Some error encountered. Ususally the unwinder doesn't |
| diagnose these and merely crashes. */ |
| return _URC_FATAL_PHASE1_ERROR; |
| |
| /* Unwind successful. Run the personality routine, if any. */ |
| if (fs.personality) |
| { |
| code = (*fs.personality) (1, _UA_SEARCH_PHASE, exc->exception_class, |
| exc, &cur_context); |
| if (code == _URC_HANDLER_FOUND) |
| break; |
| else if (code != _URC_CONTINUE_UNWIND) |
| return _URC_FATAL_PHASE1_ERROR; |
| } |
| |
| uw_update_context (&cur_context, &fs); |
| } |
| |
| /* Indicate to _Unwind_Resume and associated subroutines that this |
| is not a forced unwind. Further, note where we found a handler. */ |
| exc->private_1 = 0; |
| exc->private_2 = uw_identify_context (&cur_context); |
| |
| cur_context = this_context; |
| code = _Unwind_RaiseException_Phase2 (exc, &cur_context); |
| if (code != _URC_INSTALL_CONTEXT) |
| return code; |
| |
| uw_install_context (&this_context, &cur_context); |
| } |
| |
| |
| /* Subroutine of _Unwind_ForcedUnwind also invoked from _Unwind_Resume. */ |
| |
| static _Unwind_Reason_Code |
| _Unwind_ForcedUnwind_Phase2(struct _Unwind_Exception *exc, |
| struct _Unwind_Context *context) |
| { |
| _Unwind_Stop_Fn stop = (_Unwind_Stop_Fn) exc->private_1; |
| void *stop_argument = (void *) exc->private_2; |
| _Unwind_Reason_Code code, stop_code; |
| |
| while (1) |
| { |
| _Unwind_FrameState fs; |
| |
| code = uw_frame_state_for (context, &fs); |
| if (code != _URC_NO_REASON && code != _URC_END_OF_STACK) |
| return _URC_FATAL_PHASE2_ERROR; |
| |
| /* Unwind successful. */ |
| stop_code = (*stop) (1, _UA_FORCE_UNWIND | _UA_CLEANUP_PHASE, |
| exc->exception_class, exc, context, stop_argument); |
| if (stop_code != _URC_NO_REASON) |
| return _URC_FATAL_PHASE2_ERROR; |
| |
| /* Stop didn't want to do anything. Invoke the personality |
| handler, if applicable, to run cleanups. */ |
| if (code == _URC_END_OF_STACK) |
| break; |
| |
| if (fs.personality) |
| { |
| code = (*fs.personality) (1, _UA_FORCE_UNWIND | _UA_CLEANUP_PHASE, |
| exc->exception_class, exc, context); |
| if (code == _URC_INSTALL_CONTEXT) |
| break; |
| if (code != _URC_CONTINUE_UNWIND) |
| return _URC_FATAL_PHASE2_ERROR; |
| } |
| |
| uw_update_context (context, &fs); |
| } |
| |
| return code; |
| } |
| |
| |
| /* Raise an exception for forced unwinding. */ |
| |
| _Unwind_Reason_Code |
| _Unwind_ForcedUnwind (struct _Unwind_Exception *exc, |
| _Unwind_Stop_Fn stop, void * stop_argument) |
| { |
| struct _Unwind_Context this_context, cur_context; |
| _Unwind_Reason_Code code; |
| |
| uw_init_context (&this_context); |
| cur_context = this_context; |
| |
| exc->private_1 = (_Unwind_Ptr) stop; |
| exc->private_2 = (_Unwind_Ptr) stop_argument; |
| |
| code = _Unwind_ForcedUnwind_Phase2 (exc, &cur_context); |
| if (code != _URC_INSTALL_CONTEXT) |
| return code; |
| |
| uw_install_context (&this_context, &cur_context); |
| } |
| |
| |
| /* Resume propagation of an existing exception. This is used after |
| e.g. executing cleanup code, and not to implement rethrowing. */ |
| |
| void |
| _Unwind_Resume (struct _Unwind_Exception *exc) |
| { |
| struct _Unwind_Context this_context, cur_context; |
| _Unwind_Reason_Code code; |
| |
| uw_init_context (&this_context); |
| cur_context = this_context; |
| |
| /* Choose between continuing to process _Unwind_RaiseException |
| or _Unwind_ForcedUnwind. */ |
| if (exc->private_1 == 0) |
| code = _Unwind_RaiseException_Phase2 (exc, &cur_context); |
| else |
| code = _Unwind_ForcedUnwind_Phase2 (exc, &cur_context); |
| |
| if (code != _URC_INSTALL_CONTEXT) |
| abort (); |
| |
| uw_install_context (&this_context, &cur_context); |
| } |
| |
| /* A convenience function that calls the exception_cleanup field. */ |
| |
| void |
| _Unwind_DeleteException (struct _Unwind_Exception *exc) |
| { |
| (*exc->exception_cleanup) (_URC_FOREIGN_EXCEPTION_CAUGHT, exc); |
| } |