gcc/unwind.inc

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