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
  76 /* Raise an exception, passing along the given exception object.  */
  77
  78 _Unwind_Reason_Code
  79 _Unwind_RaiseException(struct _Unwind_Exception *exc)
  80 {
  81   struct _Unwind_Context this_context, cur_context;
  82   _Unwind_Reason_Code code;
  83
  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       code = uw_frame_state_for (&cur_context, &fs);
  94
  95       if (code == _URC_END_OF_STACK)
  96         /* Hit end of stack with no handler found.  */
  97         return _URC_END_OF_STACK;
  98
  99       if (code != _URC_NO_REASON)
 100         /* Some error encountered.  Ususally the unwinder doesn't
 101            diagnose these and merely crashes.  */
 102         return _URC_FATAL_PHASE1_ERROR;
 103
 104       /* Unwind successful.  Run the personality routine, if any.  */
 105       if (fs.personality)
 106         {
 107           code = (*fs.personality) (1, _UA_SEARCH_PHASE, exc->exception_class,
 108                                     exc, &cur_context);
 109           if (code == _URC_HANDLER_FOUND)
 110             break;
 111           else if (code != _URC_CONTINUE_UNWIND)
 112             return _URC_FATAL_PHASE1_ERROR;
 113         }
 114
 115       uw_update_context (&cur_context, &fs);
 116     }
 117
 118   /* Indicate to _Unwind_Resume and associated subroutines that this
 119      is not a forced unwind.  Further, note where we found a handler.  */
 120   exc->private_1 = 0;
 121   exc->private_2 = uw_identify_context (&cur_context);
 122
 123   cur_context = this_context;
 124   code = _Unwind_RaiseException_Phase2 (exc, &cur_context);
 125   if (code != _URC_INSTALL_CONTEXT)
 126     return code;
 127
 128   uw_install_context (&this_context, &cur_context);
 129 }
 130
 131
 132 /* Subroutine of _Unwind_ForcedUnwind also invoked from _Unwind_Resume.  */
 133
 134 static _Unwind_Reason_Code
 135 _Unwind_ForcedUnwind_Phase2(struct _Unwind_Exception *exc,
 136                             struct _Unwind_Context *context)
 137 {
 138   _Unwind_Stop_Fn stop = (_Unwind_Stop_Fn) (_Unwind_Ptr) exc->private_1;
 139   void *stop_argument = (void *) (_Unwind_Ptr) exc->private_2;
 140   _Unwind_Reason_Code code, stop_code;
 141
 142   while (1)
 143     {
 144       _Unwind_FrameState fs;
 145       int action;
 146
 147       code = uw_frame_state_for (context, &fs);
 148       if (code != _URC_NO_REASON && code != _URC_END_OF_STACK)
 149         return _URC_FATAL_PHASE2_ERROR;
 150
 151       /* Unwind successful.  */
 152       action = _UA_FORCE_UNWIND | _UA_CLEANUP_PHASE;
 153       if (code == _URC_END_OF_STACK)
 154         action |= _UA_END_OF_STACK;
 155       stop_code = (*stop) (1, action, exc->exception_class, exc,
 156                            context, stop_argument);
 157       if (stop_code != _URC_NO_REASON)
 158         return _URC_FATAL_PHASE2_ERROR;
 159
 160       /* Stop didn't want to do anything.  Invoke the personality
 161          handler, if applicable, to run cleanups.  */
 162       if (code == _URC_END_OF_STACK)
 163         break;
 164
 165       if (fs.personality)
 166         {
 167           code = (*fs.personality) (1, _UA_FORCE_UNWIND | _UA_CLEANUP_PHASE,
 168                                     exc->exception_class, exc, context);
 169           if (code == _URC_INSTALL_CONTEXT)
 170             break;
 171           if (code != _URC_CONTINUE_UNWIND)
 172             return _URC_FATAL_PHASE2_ERROR;
 173         }
 174
 175       uw_update_context (context, &fs);
 176     }
 177
 178   return code;
 179 }
 180
 181
 182 /* Raise an exception for forced unwinding.  */
 183
 184 _Unwind_Reason_Code
 185 _Unwind_ForcedUnwind (struct _Unwind_Exception *exc,
 186                       _Unwind_Stop_Fn stop, void * stop_argument)
 187 {
 188   struct _Unwind_Context this_context, cur_context;
 189   _Unwind_Reason_Code code;
 190
 191   uw_init_context (&this_context);
 192   cur_context = this_context;
 193
 194   exc->private_1 = (_Unwind_Ptr) stop;
 195   exc->private_2 = (_Unwind_Ptr) stop_argument;
 196
 197   code = _Unwind_ForcedUnwind_Phase2 (exc, &cur_context);
 198   if (code != _URC_INSTALL_CONTEXT)
 199     return code;
 200
 201   uw_install_context (&this_context, &cur_context);
 202 }
 203
 204
 205 /* Resume propagation of an existing exception.  This is used after
 206    e.g. executing cleanup code, and not to implement rethrowing.  */
 207
 208 void
 209 _Unwind_Resume (struct _Unwind_Exception *exc)
 210 {
 211   struct _Unwind_Context this_context, cur_context;
 212   _Unwind_Reason_Code code;
 213
 214   uw_init_context (&this_context);
 215   cur_context = this_context;
 216
 217   /* Choose between continuing to process _Unwind_RaiseException
 218      or _Unwind_ForcedUnwind.  */
 219   if (exc->private_1 == 0)
 220     code = _Unwind_RaiseException_Phase2 (exc, &cur_context);
 221   else
 222     code = _Unwind_ForcedUnwind_Phase2 (exc, &cur_context);
 223
 224   if (code != _URC_INSTALL_CONTEXT)
 225     abort ();
 226
 227   uw_install_context (&this_context, &cur_context);
 228 }
 229
 230 /* A convenience function that calls the exception_cleanup field.  */
 231
 232 void
 233 _Unwind_DeleteException (struct _Unwind_Exception *exc)
 234 {
 235   (*exc->exception_cleanup) (_URC_FOREIGN_EXCEPTION_CAUGHT, exc);
 236 }