1/* Exception handling and frame unwind runtime interface routines. -*- C -*- 2 Copyright (C) 2001, 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 it 7 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 In addition to the permissions in the GNU General Public License, the 12 Free Software Foundation gives you unlimited permission to link the 13 compiled version of this file into combinations with other programs, 14 and to distribute those combinations without any restriction coming 15 from the use of this file. (The General Public License restrictions 16 do apply in other respects; for example, they cover modification of 17 the file, and distribution when not linked into a combined 18 executable.) 19 20 GCC is distributed in the hope that it will be useful, but WITHOUT 21 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 22 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public 23 License for more details. 24 25 You should have received a copy of the GNU General Public License 26 along with GCC; see the file COPYING. If not, write to the Free 27 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 28 02110-1301, USA. */ 29 30/* This is derived from the C++ ABI for IA-64. Where we diverge 31 for cross-architecture compatibility are noted with "@@@". 32 This file is included from unwind-dw2.c or unwind-ia64.c. */ 33 34/* Subroutine of _Unwind_RaiseException also invoked from _Unwind_Resume. 35 36 Unwind the stack calling the personality routine to find both the 37 exception handler and intermediary cleanup code. We'll only locate 38 the first such frame here. Cleanup code will call back into 39 _Unwind_Resume and we'll continue Phase 2 there. */ 40 41static _Unwind_Reason_Code 42_Unwind_RaiseException_Phase2(struct _Unwind_Exception *exc, 43 struct _Unwind_Context *context) 44{ 45 _Unwind_Reason_Code code; 46 47 while (1) 48 { 49 _Unwind_FrameState fs; 50 int match_handler; 51 52 code = uw_frame_state_for (context, &fs); 53 54 /* Identify when we've reached the designated handler context. */ 55 match_handler = (uw_identify_context (context) == exc->private_2 56 ? _UA_HANDLER_FRAME : 0); 57 58 if (code != _URC_NO_REASON) 59 /* Some error encountered. Usually the unwinder doesn't 60 diagnose these and merely crashes. */ 61 return _URC_FATAL_PHASE2_ERROR; 62 63 /* Unwind successful. Run the personality routine, if any. */ 64 if (fs.personality) 65 { 66 code = (*fs.personality) (1, _UA_CLEANUP_PHASE | match_handler, 67 exc->exception_class, exc, context); 68 if (code == _URC_INSTALL_CONTEXT) 69 break; 70 if (code != _URC_CONTINUE_UNWIND) 71 return _URC_FATAL_PHASE2_ERROR; 72 } 73 74 /* Don't let us unwind past the handler context. */ 75 gcc_assert (!match_handler); 76 77 uw_update_context (context, &fs); 78 } 79 80 return code; 81} 82 83/* Raise an exception, passing along the given exception object. */ 84 85_Unwind_Reason_Code 86_Unwind_RaiseException(struct _Unwind_Exception *exc) 87{ 88 struct _Unwind_Context this_context, cur_context; 89 _Unwind_Reason_Code code; 90 91 /* Set up this_context to describe the current stack frame. */ 92 uw_init_context (&this_context); 93 cur_context = this_context; 94 95 /* Phase 1: Search. Unwind the stack, calling the personality routine 96 with the _UA_SEARCH_PHASE flag set. Do not modify the stack yet. */ 97 while (1) 98 { 99 _Unwind_FrameState fs; 100 101 /* Set up fs to describe the FDE for the caller of cur_context. The 102 first time through the loop, that means __cxa_throw. */ 103 code = uw_frame_state_for (&cur_context, &fs); 104 105 if (code == _URC_END_OF_STACK) 106 /* Hit end of stack with no handler found. */ 107 return _URC_END_OF_STACK; 108 109 if (code != _URC_NO_REASON) 110 /* Some error encountered. Ususally the unwinder doesn't 111 diagnose these and merely crashes. */ 112 return _URC_FATAL_PHASE1_ERROR; 113 114 /* Unwind successful. Run the personality routine, if any. */ 115 if (fs.personality) 116 { 117 code = (*fs.personality) (1, _UA_SEARCH_PHASE, exc->exception_class, 118 exc, &cur_context); 119 if (code == _URC_HANDLER_FOUND) 120 break; 121 else if (code != _URC_CONTINUE_UNWIND) 122 return _URC_FATAL_PHASE1_ERROR; 123 } 124 125 /* Update cur_context to describe the same frame as fs. */ 126 uw_update_context (&cur_context, &fs); 127 } 128 129 /* Indicate to _Unwind_Resume and associated subroutines that this 130 is not a forced unwind. Further, note where we found a handler. */ 131 exc->private_1 = 0; 132 exc->private_2 = uw_identify_context (&cur_context); 133 134 cur_context = this_context; 135 code = _Unwind_RaiseException_Phase2 (exc, &cur_context); 136 if (code != _URC_INSTALL_CONTEXT) 137 return code; 138 139 uw_install_context (&this_context, &cur_context); 140} 141 142 143/* Subroutine of _Unwind_ForcedUnwind also invoked from _Unwind_Resume. */ 144 145static _Unwind_Reason_Code 146_Unwind_ForcedUnwind_Phase2 (struct _Unwind_Exception *exc, 147 struct _Unwind_Context *context) 148{ 149 _Unwind_Stop_Fn stop = (_Unwind_Stop_Fn) (_Unwind_Ptr) exc->private_1; 150 void *stop_argument = (void *) (_Unwind_Ptr) exc->private_2; 151 _Unwind_Reason_Code code, stop_code; 152 153 while (1) 154 { 155 _Unwind_FrameState fs; 156 int action; 157 158 /* Set up fs to describe the FDE for the caller of cur_context. */ 159 code = uw_frame_state_for (context, &fs); 160 if (code != _URC_NO_REASON && code != _URC_END_OF_STACK) 161 return _URC_FATAL_PHASE2_ERROR; 162 163 /* Unwind successful. */ 164 action = _UA_FORCE_UNWIND | _UA_CLEANUP_PHASE; 165 if (code == _URC_END_OF_STACK) 166 action |= _UA_END_OF_STACK; 167 stop_code = (*stop) (1, action, exc->exception_class, exc, 168 context, stop_argument); 169 if (stop_code != _URC_NO_REASON) 170 return _URC_FATAL_PHASE2_ERROR; 171 172 /* Stop didn't want to do anything. Invoke the personality 173 handler, if applicable, to run cleanups. */ 174 if (code == _URC_END_OF_STACK) 175 break; 176 177 if (fs.personality) 178 { 179 code = (*fs.personality) (1, _UA_FORCE_UNWIND | _UA_CLEANUP_PHASE, 180 exc->exception_class, exc, context); 181 if (code == _URC_INSTALL_CONTEXT) 182 break; 183 if (code != _URC_CONTINUE_UNWIND) 184 return _URC_FATAL_PHASE2_ERROR; 185 } 186 187 /* Update cur_context to describe the same frame as fs, and discard 188 the previous context if necessary. */ 189 uw_advance_context (context, &fs); 190 } 191 192 return code; 193} 194 195 196/* Raise an exception for forced unwinding. */ 197 198_Unwind_Reason_Code 199_Unwind_ForcedUnwind (struct _Unwind_Exception *exc, 200 _Unwind_Stop_Fn stop, void * stop_argument) 201{ 202 struct _Unwind_Context this_context, cur_context; 203 _Unwind_Reason_Code code; 204 205 uw_init_context (&this_context); 206 cur_context = this_context; 207 208 exc->private_1 = (_Unwind_Ptr) stop; 209 exc->private_2 = (_Unwind_Ptr) stop_argument; 210 211 code = _Unwind_ForcedUnwind_Phase2 (exc, &cur_context); 212 if (code != _URC_INSTALL_CONTEXT) 213 return code; 214 215 uw_install_context (&this_context, &cur_context); 216} 217 218 219/* Resume propagation of an existing exception. This is used after 220 e.g. executing cleanup code, and not to implement rethrowing. */ 221 222void 223_Unwind_Resume (struct _Unwind_Exception *exc) 224{ 225 struct _Unwind_Context this_context, cur_context; 226 _Unwind_Reason_Code code; 227 228 uw_init_context (&this_context); 229 cur_context = this_context; 230 231 /* Choose between continuing to process _Unwind_RaiseException 232 or _Unwind_ForcedUnwind. */ 233 if (exc->private_1 == 0) 234 code = _Unwind_RaiseException_Phase2 (exc, &cur_context); 235 else 236 code = _Unwind_ForcedUnwind_Phase2 (exc, &cur_context); 237 238 gcc_assert (code == _URC_INSTALL_CONTEXT); 239 240 uw_install_context (&this_context, &cur_context); 241} 242 243 244/* Resume propagation of an FORCE_UNWIND exception, or to rethrow 245 a normal exception that was handled. */ 246 247_Unwind_Reason_Code 248_Unwind_Resume_or_Rethrow (struct _Unwind_Exception *exc) 249{ 250 struct _Unwind_Context this_context, cur_context; 251 _Unwind_Reason_Code code; 252 253 /* Choose between continuing to process _Unwind_RaiseException 254 or _Unwind_ForcedUnwind. */ 255 if (exc->private_1 == 0) 256 return _Unwind_RaiseException (exc); 257 258 uw_init_context (&this_context); 259 cur_context = this_context; 260 261 code = _Unwind_ForcedUnwind_Phase2 (exc, &cur_context); 262 263 gcc_assert (code == _URC_INSTALL_CONTEXT); 264 265 uw_install_context (&this_context, &cur_context); 266} 267 268 269/* A convenience function that calls the exception_cleanup field. */ 270 271void 272_Unwind_DeleteException (struct _Unwind_Exception *exc) 273{ 274 if (exc->exception_cleanup) 275 (*exc->exception_cleanup) (_URC_FOREIGN_EXCEPTION_CAUGHT, exc); 276} 277 278 279/* Perform stack backtrace through unwind data. */ 280 281_Unwind_Reason_Code 282_Unwind_Backtrace(_Unwind_Trace_Fn trace, void * trace_argument) 283{ 284 struct _Unwind_Context context; 285 _Unwind_Reason_Code code; 286 287 uw_init_context (&context); 288 289 while (1) 290 { 291 _Unwind_FrameState fs; 292 293 /* Set up fs to describe the FDE for the caller of context. */ 294 code = uw_frame_state_for (&context, &fs); 295 if (code != _URC_NO_REASON && code != _URC_END_OF_STACK) 296 return _URC_FATAL_PHASE1_ERROR; 297 298 /* Call trace function. */ 299 if ((*trace) (&context, trace_argument) != _URC_NO_REASON) 300 return _URC_FATAL_PHASE1_ERROR; 301 302 /* We're done at end of stack. */ 303 if (code == _URC_END_OF_STACK) 304 break; 305 306 /* Update context to describe the same frame as fs. */ 307 uw_update_context (&context, &fs); 308 } 309 310 return code; 311} 312