gdb/exceptions.c

   1 /* Exception (throw catch) mechanism, for GDB, the GNU debugger.
   2
   3    Copyright 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
   4    1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software
   5    Foundation, Inc.
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 2 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 59 Temple Place - Suite 330,
  22    Boston, MA 02111-1307, USA.  */
  23
  24 #include "defs.h"
  25 #include "exceptions.h"
  26 #include <setjmp.h>
  27 #include "breakpoint.h"
  28 #include "target.h"
  29 #include "inferior.h"
  30 #include "annotate.h"
  31 #include "ui-out.h"
  32 #include "gdb_assert.h"
  33
  34 /* One should use catch_errors rather than manipulating these
  35    directly.  */
  36 #if defined(HAVE_SIGSETJMP)
  37 #define SIGJMP_BUF              sigjmp_buf
  38 #define SIGSETJMP(buf)          sigsetjmp((buf), 1)
  39 #define SIGLONGJMP(buf,val)     siglongjmp((buf), (val))
  40 #else
  41 #define SIGJMP_BUF              jmp_buf
  42 #define SIGSETJMP(buf)          setjmp(buf)
  43 #define SIGLONGJMP(buf,val)     longjmp((buf), (val))
  44 #endif
  45
  46 /* Where to go for throw_exception().  */
  47 static SIGJMP_BUF *catch_return;
  48
  49 /* Return for reason REASON to the nearest containing catch_errors().  */
  50
  51 NORETURN void
  52 throw_exception (enum return_reason reason)
  53 {
  54   quit_flag = 0;
  55   immediate_quit = 0;
  56
  57   /* Perhaps it would be cleaner to do this via the cleanup chain (not sure
  58      I can think of a reason why that is vital, though).  */
  59   bpstat_clear_actions (stop_bpstat);   /* Clear queued breakpoint commands */
  60
  61   disable_current_display ();
  62   do_cleanups (ALL_CLEANUPS);
  63   if (target_can_async_p () && !target_executing)
  64     do_exec_cleanups (ALL_CLEANUPS);
  65   if (sync_execution)
  66     do_exec_error_cleanups (ALL_CLEANUPS);
  67
  68   if (annotation_level > 1)
  69     switch (reason)
  70       {
  71       case RETURN_QUIT:
  72         annotate_quit ();
  73         break;
  74       case RETURN_ERROR:
  75         annotate_error ();
  76         break;
  77       }
  78
  79   /* Jump to the containing catch_errors() call, communicating REASON
  80      to that call via setjmp's return value.  Note that REASON can't
  81      be zero, by definition in defs.h. */
  82
  83   (NORETURN void) SIGLONGJMP (*catch_return, (int) reason);
  84 }
  85
  86 /* Call FUNC() with args FUNC_UIOUT and FUNC_ARGS, catching any
  87    errors.  Set FUNC_CAUGHT to an ``enum return_reason'' if the
  88    function is aborted (using throw_exception() or zero if the
  89    function returns normally.  Set FUNC_VAL to the value returned by
  90    the function or 0 if the function was aborted.
  91
  92    Must not be called with immediate_quit in effect (bad things might
  93    happen, say we got a signal in the middle of a memcpy to quit_return).
  94    This is an OK restriction; with very few exceptions immediate_quit can
  95    be replaced by judicious use of QUIT.
  96
  97    MASK specifies what to catch; it is normally set to
  98    RETURN_MASK_ALL, if for no other reason than that the code which
  99    calls catch_errors might not be set up to deal with a quit which
 100    isn't caught.  But if the code can deal with it, it generally
 101    should be RETURN_MASK_ERROR, unless for some reason it is more
 102    useful to abort only the portion of the operation inside the
 103    catch_errors.  Note that quit should return to the command line
 104    fairly quickly, even if some further processing is being done.  */
 105
 106 /* MAYBE: cagney/1999-11-05: catch_errors() in conjunction with
 107    error() et.al. could maintain a set of flags that indicate the the
 108    current state of each of the longjmp buffers.  This would give the
 109    longjmp code the chance to detect a longjmp botch (before it gets
 110    to longjmperror()).  Prior to 1999-11-05 this wasn't possible as
 111    code also randomly used a SET_TOP_LEVEL macro that directly
 112    initialize the longjmp buffers. */
 113
 114 /* MAYBE: cagney/1999-11-05: Should the catch_errors and cleanups code
 115    be consolidated into a single file instead of being distributed
 116    between utils.c and top.c? */
 117
 118 static void
 119 catcher (catch_exceptions_ftype *func,
 120          struct ui_out *func_uiout,
 121          void *func_args,
 122          int *func_val,
 123          enum return_reason *func_caught,
 124          char *errstring,
 125          char **gdberrmsg,
 126          return_mask mask)
 127 {
 128   SIGJMP_BUF *saved_catch;
 129   SIGJMP_BUF catch;
 130   struct cleanup *saved_cleanup_chain;
 131   char *saved_error_pre_print;
 132   char *saved_quit_pre_print;
 133   struct ui_out *saved_uiout;
 134
 135   /* Return value from SIGSETJMP(): enum return_reason if error or
 136      quit caught, 0 otherwise. */
 137   int caught;
 138
 139   /* Return value from FUNC(): Hopefully non-zero. Explicitly set to
 140      zero if an error quit was caught.  */
 141   int val;
 142
 143   /* Override error/quit messages during FUNC. */
 144
 145   saved_error_pre_print = error_pre_print;
 146   saved_quit_pre_print = quit_pre_print;
 147
 148   if (mask & RETURN_MASK_ERROR)
 149     error_pre_print = errstring;
 150   if (mask & RETURN_MASK_QUIT)
 151     quit_pre_print = errstring;
 152
 153   /* Override the global ``struct ui_out'' builder.  */
 154
 155   saved_uiout = uiout;
 156   uiout = func_uiout;
 157
 158   /* Prevent error/quit during FUNC from calling cleanups established
 159      prior to here. */
 160
 161   saved_cleanup_chain = save_cleanups ();
 162
 163   /* Call FUNC, catching error/quit events. */
 164
 165   saved_catch = catch_return;
 166   catch_return = &catch;
 167   caught = SIGSETJMP (catch);
 168   if (!caught)
 169     val = (*func) (func_uiout, func_args);
 170   else
 171     {
 172       val = 0;
 173       /* If caller wants a copy of the low-level error message, make one.
 174          This is used in the case of a silent error whereby the caller
 175          may optionally want to issue the message.  */
 176       if (gdberrmsg)
 177         *gdberrmsg = error_last_message ();
 178     }
 179   catch_return = saved_catch;
 180
 181   /* FIXME: cagney/1999-11-05: A correct FUNC implementation will
 182      clean things up (restoring the cleanup chain) to the state they
 183      were just prior to the call.  Unfortunately, many FUNC's are not
 184      that well behaved.  This could be fixed by adding either a
 185      do_cleanups call (to cover the problem) or an assertion check to
 186      detect bad FUNCs code. */
 187
 188   /* Restore the cleanup chain, the error/quit messages, and the uiout
 189      builder, to their original states. */
 190
 191   restore_cleanups (saved_cleanup_chain);
 192
 193   uiout = saved_uiout;
 194
 195   if (mask & RETURN_MASK_QUIT)
 196     quit_pre_print = saved_quit_pre_print;
 197   if (mask & RETURN_MASK_ERROR)
 198     error_pre_print = saved_error_pre_print;
 199
 200   /* Return normally if no error/quit event occurred or this catcher
 201      can handle this exception.  The caller analyses the func return
 202      values.  */
 203
 204   if (!caught || (mask & RETURN_MASK (caught)))
 205     {
 206       *func_val = val;
 207       *func_caught = caught;
 208       return;
 209     }
 210
 211   /* The caller didn't request that the event be caught, relay the
 212      event to the next containing catch_errors(). */
 213
 214   throw_exception (caught);
 215 }
 216
 217 int
 218 catch_exceptions (struct ui_out *uiout,
 219                   catch_exceptions_ftype *func,
 220                   void *func_args,
 221                   char *errstring,
 222                   return_mask mask)
 223 {
 224   int val;
 225   enum return_reason caught;
 226   catcher (func, uiout, func_args, &val, &caught, errstring, NULL, mask);
 227   gdb_assert (val >= 0);
 228   gdb_assert (caught <= 0);
 229   if (caught < 0)
 230     return caught;
 231   return val;
 232 }
 233
 234 int
 235 catch_exceptions_with_msg (struct ui_out *uiout,
 236                            catch_exceptions_ftype *func,
 237                            void *func_args,
 238                            char *errstring,
 239                            char **gdberrmsg,
 240                            return_mask mask)
 241 {
 242   int val;
 243   enum return_reason caught;
 244   catcher (func, uiout, func_args, &val, &caught, errstring, gdberrmsg, mask);
 245   gdb_assert (val >= 0);
 246   gdb_assert (caught <= 0);
 247   if (caught < 0)
 248     return caught;
 249   return val;
 250 }
 251
 252 struct catch_errors_args
 253 {
 254   catch_errors_ftype *func;
 255   void *func_args;
 256 };
 257
 258 static int
 259 do_catch_errors (struct ui_out *uiout, void *data)
 260 {
 261   struct catch_errors_args *args = data;
 262   return args->func (args->func_args);
 263 }
 264
 265 int
 266 catch_errors (catch_errors_ftype *func, void *func_args, char *errstring,
 267               return_mask mask)
 268 {
 269   int val;
 270   enum return_reason caught;
 271   struct catch_errors_args args;
 272   args.func = func;
 273   args.func_args = func_args;
 274   catcher (do_catch_errors, uiout, &args, &val, &caught, errstring,
 275            NULL, mask);
 276   if (caught != 0)
 277     return 0;
 278   return val;
 279 }
 280
 281 struct captured_command_args
 282   {
 283     catch_command_errors_ftype *command;
 284     char *arg;
 285     int from_tty;
 286   };
 287
 288 static int
 289 do_captured_command (void *data)
 290 {
 291   struct captured_command_args *context = data;
 292   context->command (context->arg, context->from_tty);
 293   /* FIXME: cagney/1999-11-07: Technically this do_cleanups() call
 294      isn't needed.  Instead an assertion check could be made that
 295      simply confirmed that the called function correctly cleaned up
 296      after itself.  Unfortunately, old code (prior to 1999-11-04) in
 297      main.c was calling SET_TOP_LEVEL(), calling the command function,
 298      and then *always* calling do_cleanups().  For the moment we
 299      remain ``bug compatible'' with that old code..  */
 300   do_cleanups (ALL_CLEANUPS);
 301   return 1;
 302 }
 303
 304 int
 305 catch_command_errors (catch_command_errors_ftype * command,
 306                       char *arg, int from_tty, return_mask mask)
 307 {
 308   struct captured_command_args args;
 309   args.command = command;
 310   args.arg = arg;
 311   args.from_tty = from_tty;
 312   return catch_errors (do_captured_command, &args, "", mask);
 313 }