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, 2005 Free
   5    Software 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 #include "gdb_string.h"
  34
  35 const struct exception exception_none = { 0, NO_ERROR, NULL };
  36
  37 /* One should use catch_errors rather than manipulating these
  38    directly.  */
  39 #if defined(HAVE_SIGSETJMP)
  40 #define SIGJMP_BUF              sigjmp_buf
  41 #define SIGSETJMP(buf)          sigsetjmp((buf), 1)
  42 #define SIGLONGJMP(buf,val)     siglongjmp((buf), (val))
  43 #else
  44 #define SIGJMP_BUF              jmp_buf
  45 #define SIGSETJMP(buf)          setjmp(buf)
  46 #define SIGLONGJMP(buf,val)     longjmp((buf), (val))
  47 #endif
  48
  49 /* Possible catcher states.  */
  50 enum catcher_state {
  51   /* Initial state, a new catcher has just been created.  */
  52   CATCHER_CREATED,
  53   /* The catch code is running.  */
  54   CATCHER_RUNNING,
  55   CATCHER_RUNNING_1,
  56   /* The catch code threw an exception.  */
  57   CATCHER_ABORTING
  58 };
  59
  60 /* Possible catcher actions.  */
  61 enum catcher_action {
  62   CATCH_ITER,
  63   CATCH_ITER_1,
  64   CATCH_THROWING
  65 };
  66
  67 struct catcher
  68 {
  69   enum catcher_state state;
  70   /* Jump buffer pointing back at the exception handler.  */
  71   SIGJMP_BUF buf;
  72   /* Status buffer belonging to the exception handler.  */
  73   volatile struct exception *exception;
  74   /* Saved/current state.  */
  75   int mask;
  76   char *saved_error_pre_print;
  77   char *saved_quit_pre_print;
  78   struct ui_out *saved_uiout;
  79   struct cleanup *saved_cleanup_chain;
  80   /* Back link.  */
  81   struct catcher *prev;
  82 };
  83
  84 /* Where to go for throw_exception().  */
  85 static struct catcher *current_catcher;
  86
  87 static SIGJMP_BUF *
  88 catcher_init (struct ui_out *func_uiout,
  89               char *errstring,
  90               volatile struct exception *exception,
  91               return_mask mask)
  92 {
  93   struct catcher *new_catcher = XZALLOC (struct catcher);
  94
  95   /* Start with no exception, save it's address.  */
  96   exception->reason = 0;
  97   exception->error = NO_ERROR;
  98   exception->message = NULL;
  99   new_catcher->exception = exception;
 100
 101   new_catcher->mask = mask;
 102
 103   /* Override error/quit messages during FUNC. */
 104   new_catcher->saved_error_pre_print = error_pre_print;
 105   new_catcher->saved_quit_pre_print = quit_pre_print;
 106   if (mask & RETURN_MASK_ERROR)
 107     error_pre_print = errstring;
 108   if (mask & RETURN_MASK_QUIT)
 109     quit_pre_print = errstring;
 110
 111   /* Override the global ``struct ui_out'' builder.  */
 112   new_catcher->saved_uiout = uiout;
 113   uiout = func_uiout;
 114
 115   /* Prevent error/quit during FUNC from calling cleanups established
 116      prior to here. */
 117   new_catcher->saved_cleanup_chain = save_cleanups ();
 118
 119   /* Push this new catcher on the top.  */
 120   new_catcher->prev = current_catcher;
 121   current_catcher = new_catcher;
 122   new_catcher->state = CATCHER_CREATED;
 123
 124   return &new_catcher->buf;
 125 }
 126
 127 static void
 128 catcher_pop (void)
 129 {
 130   struct catcher *old_catcher = current_catcher;
 131   current_catcher = old_catcher->prev;
 132
 133   /* Restore the cleanup chain, the error/quit messages, and the uiout
 134      builder, to their original states. */
 135
 136   restore_cleanups (old_catcher->saved_cleanup_chain);
 137
 138   uiout = old_catcher->saved_uiout;
 139
 140   quit_pre_print = old_catcher->saved_quit_pre_print;
 141   error_pre_print = old_catcher->saved_error_pre_print;
 142
 143   xfree (old_catcher);
 144 }
 145
 146 /* Catcher state machine.  Returns non-zero if the m/c should be run
 147    again, zero if it should abort.  */
 148
 149 int
 150 catcher_state_machine (enum catcher_action action)
 151 {
 152   switch (current_catcher->state)
 153     {
 154     case CATCHER_CREATED:
 155       switch (action)
 156         {
 157         case CATCH_ITER:
 158           /* Allow the code to run the catcher.  */
 159           current_catcher->state = CATCHER_RUNNING;
 160           return 1;
 161         default:
 162           internal_error (__FILE__, __LINE__, "bad state");
 163         }
 164     case CATCHER_RUNNING:
 165       switch (action)
 166         {
 167         case CATCH_ITER:
 168           /* No error/quit has occured.  Just clean up.  */
 169           catcher_pop ();
 170           return 0;
 171         case CATCH_ITER_1:
 172           current_catcher->state = CATCHER_RUNNING_1;
 173           return 1;
 174         case CATCH_THROWING:
 175           current_catcher->state = CATCHER_ABORTING;
 176           /* See also throw_exception.  */
 177           return 1;
 178         default:
 179           internal_error (__FILE__, __LINE__, "bad switch");
 180         }
 181     case CATCHER_RUNNING_1:
 182       switch (action)
 183         {
 184         case CATCH_ITER:
 185           /* The did a "break" from the inner while loop.  */
 186           catcher_pop ();
 187           return 0;
 188         case CATCH_ITER_1:
 189           current_catcher->state = CATCHER_RUNNING;
 190           return 0;
 191         case CATCH_THROWING:
 192           current_catcher->state = CATCHER_ABORTING;
 193           /* See also throw_exception.  */
 194           return 1;
 195         default:
 196           internal_error (__FILE__, __LINE__, "bad switch");
 197         }
 198     case CATCHER_ABORTING:
 199       switch (action)
 200         {
 201         case CATCH_ITER:
 202           {
 203             struct exception exception = *current_catcher->exception;
 204             if (current_catcher->mask & RETURN_MASK (exception.reason))
 205               {
 206                 /* Exit normally if this catcher can handle this
 207                    exception.  The caller analyses the func return
 208                    values.  */
 209                 catcher_pop ();
 210                 return 0;
 211               }
 212             /* The caller didn't request that the event be caught,
 213                relay the event to the next containing
 214                catch_errors(). */
 215             catcher_pop ();
 216             throw_exception (exception);
 217           }
 218         default:
 219           internal_error (__FILE__, __LINE__, "bad state");
 220         }
 221     default:
 222       internal_error (__FILE__, __LINE__, "bad switch");
 223     }
 224 }
 225
 226 /* Return EXCEPTION to the nearest containing catch_errors().  */
 227
 228 NORETURN void
 229 throw_exception (struct exception exception)
 230 {
 231   quit_flag = 0;
 232   immediate_quit = 0;
 233
 234   /* Perhaps it would be cleaner to do this via the cleanup chain (not sure
 235      I can think of a reason why that is vital, though).  */
 236   bpstat_clear_actions (stop_bpstat);   /* Clear queued breakpoint commands */
 237
 238   disable_current_display ();
 239   do_cleanups (ALL_CLEANUPS);
 240   if (target_can_async_p () && !target_executing)
 241     do_exec_cleanups (ALL_CLEANUPS);
 242   if (sync_execution)
 243     do_exec_error_cleanups (ALL_CLEANUPS);
 244
 245   /* Jump to the containing catch_errors() call, communicating REASON
 246      to that call via setjmp's return value.  Note that REASON can't
 247      be zero, by definition in defs.h. */
 248   catcher_state_machine (CATCH_THROWING);
 249   *current_catcher->exception = exception;
 250   SIGLONGJMP (current_catcher->buf, exception.reason);
 251 }
 252
 253 static char *last_message;
 254
 255 NORETURN void
 256 throw_reason (enum return_reason reason)
 257 {
 258   struct exception exception;
 259   memset (&exception, 0, sizeof exception);
 260
 261   exception.reason = reason;
 262   switch (reason)
 263     {
 264     case RETURN_QUIT:
 265       break;
 266     case RETURN_ERROR:
 267       exception.error = GENERIC_ERROR;
 268       break;
 269     default:
 270       internal_error (__FILE__, __LINE__, "bad switch");
 271     }
 272
 273   throw_exception (exception);
 274 }
 275
 276 static void
 277 print_flush (void)
 278 {
 279   if (deprecated_error_begin_hook)
 280     deprecated_error_begin_hook ();
 281   target_terminal_ours ();
 282   wrap_here ("");               /* Force out any buffered output */
 283   gdb_flush (gdb_stdout);
 284   annotate_error_begin ();
 285 }
 286
 287 static void
 288 print_exception (struct ui_file *file, struct exception e)
 289 {
 290   /* KLUGE: cagney/2005-01-13: Write the string out one line at a time
 291      as that way the MI's behavior is preserved.  */
 292   const char *start;
 293   const char *end;
 294   for (start = e.message; start != NULL; start = end)
 295     {
 296       end = strchr (start, '\n');
 297       if (end == NULL)
 298         fputs_filtered (start, file);
 299       else
 300         {
 301           end++;
 302           ui_file_write (file, start, end - start);
 303         }
 304     }
 305   fprintf_filtered (file, "\n");
 306
 307   /* Now append the annotation.  */
 308   switch (e.reason)
 309     {
 310     case RETURN_QUIT:
 311       annotate_quit ();
 312       break;
 313     case RETURN_ERROR:
 314       /* Assume that these are all errors.  */
 315       annotate_error ();
 316       break;
 317     default:
 318       internal_error (__FILE__, __LINE__, _("Bad switch."));
 319     }
 320 }
 321
 322 void
 323 exception_print (struct ui_file *file, struct exception e)
 324 {
 325   if (e.reason < 0 && e.message != NULL)
 326     {
 327       print_flush ();
 328       print_exception (file, e);
 329     }
 330 }
 331
 332 void
 333 exception_fprintf (struct ui_file *file, struct exception e,
 334                    const char *prefix, ...)
 335 {
 336   if (e.reason < 0 && e.message != NULL)
 337     {
 338       va_list args;
 339
 340       print_flush ();
 341
 342       /* Print the prefix.  */
 343       va_start (args, prefix);
 344       vfprintf_filtered (file, prefix, args);
 345       va_end (args);
 346
 347       print_exception (file, e);
 348     }
 349 }
 350
 351 void
 352 print_any_exception (struct ui_file *file, const char *prefix,
 353                      struct exception e)
 354 {
 355   if (e.reason < 0 && e.message != NULL)
 356     {
 357       target_terminal_ours ();
 358       wrap_here ("");           /* Force out any buffered output */
 359       gdb_flush (gdb_stdout);
 360       annotate_error_begin ();
 361
 362       /* Print the prefix.  */
 363       if (prefix != NULL && prefix[0] != '\0')
 364         fputs_filtered (prefix, file);
 365       print_exception (file, e);
 366     }
 367 }
 368
 369 NORETURN static void
 370 throw_it (enum return_reason reason, enum errors error, const char *fmt,
 371           va_list ap) ATTR_NORETURN;
 372 NORETURN static void
 373 throw_it (enum return_reason reason, enum errors error, const char *fmt,
 374           va_list ap)
 375 {
 376   struct exception e;
 377
 378   /* Save the message.  */
 379   xfree (last_message);
 380   last_message = xstrvprintf (fmt, ap);
 381
 382   /* Create the exception.  */
 383   e.reason = reason;
 384   e.error = error;
 385   e.message = last_message;
 386
 387   /* Throw the exception.  */
 388   throw_exception (e);
 389 }
 390
 391 NORETURN void
 392 throw_verror (enum errors error, const char *fmt, va_list ap)
 393 {
 394   throw_it (RETURN_ERROR, error, fmt, ap);
 395 }
 396
 397 NORETURN void
 398 throw_vfatal (const char *fmt, va_list ap)
 399 {
 400   throw_it (RETURN_QUIT, NO_ERROR, fmt, ap);
 401 }
 402
 403 NORETURN void
 404 throw_error (enum errors error, const char *fmt, ...)
 405 {
 406   va_list args;
 407   va_start (args, fmt);
 408   throw_it (RETURN_ERROR, error, fmt, args);
 409   va_end (args);
 410 }
 411
 412 /* Call FUNC() with args FUNC_UIOUT and FUNC_ARGS, catching any
 413    errors.  Set FUNC_CAUGHT to an ``enum return_reason'' if the
 414    function is aborted (using throw_exception() or zero if the
 415    function returns normally.  Set FUNC_VAL to the value returned by
 416    the function or 0 if the function was aborted.
 417
 418    Must not be called with immediate_quit in effect (bad things might
 419    happen, say we got a signal in the middle of a memcpy to quit_return).
 420    This is an OK restriction; with very few exceptions immediate_quit can
 421    be replaced by judicious use of QUIT.
 422
 423    MASK specifies what to catch; it is normally set to
 424    RETURN_MASK_ALL, if for no other reason than that the code which
 425    calls catch_errors might not be set up to deal with a quit which
 426    isn't caught.  But if the code can deal with it, it generally
 427    should be RETURN_MASK_ERROR, unless for some reason it is more
 428    useful to abort only the portion of the operation inside the
 429    catch_errors.  Note that quit should return to the command line
 430    fairly quickly, even if some further processing is being done.  */
 431
 432 /* MAYBE: cagney/1999-11-05: catch_errors() in conjunction with
 433    error() et.al. could maintain a set of flags that indicate the the
 434    current state of each of the longjmp buffers.  This would give the
 435    longjmp code the chance to detect a longjmp botch (before it gets
 436    to longjmperror()).  Prior to 1999-11-05 this wasn't possible as
 437    code also randomly used a SET_TOP_LEVEL macro that directly
 438    initialize the longjmp buffers. */
 439
 440 /* MAYBE: cagney/1999-11-05: Should the catch_errors and cleanups code
 441    be consolidated into a single file instead of being distributed
 442    between utils.c and top.c? */
 443
 444 int
 445 catch_exceptions (struct ui_out *uiout,
 446                   catch_exceptions_ftype *func,
 447                   void *func_args,
 448                   return_mask mask)
 449 {
 450   return catch_exceptions_with_msg (uiout, func, func_args, NULL, mask);
 451 }
 452
 453 struct exception
 454 catch_exception (struct ui_out *uiout,
 455                  catch_exception_ftype *func,
 456                  void *func_args,
 457                  return_mask mask)
 458 {
 459   volatile struct exception exception;
 460   SIGJMP_BUF *catch;
 461   catch = catcher_init (uiout, NULL, &exception, mask);
 462   for (SIGSETJMP ((*catch));
 463        catcher_state_machine (CATCH_ITER);)
 464     (*func) (uiout, func_args);
 465   return exception;
 466 }
 467
 468 int
 469 catch_exceptions_with_msg (struct ui_out *uiout,
 470                            catch_exceptions_ftype *func,
 471                            void *func_args,
 472                            char **gdberrmsg,
 473                            return_mask mask)
 474 {
 475   volatile struct exception exception;
 476   volatile int val = 0;
 477   SIGJMP_BUF *catch = catcher_init (uiout, NULL, &exception, mask);
 478   for (SIGSETJMP ((*catch)); catcher_state_machine (CATCH_ITER);)
 479     val = (*func) (uiout, func_args);
 480   print_any_exception (gdb_stderr, NULL, exception);
 481   gdb_assert (val >= 0);
 482   gdb_assert (exception.reason <= 0);
 483   if (exception.reason < 0)
 484     {
 485       /* If caller wants a copy of the low-level error message, make
 486          one.  This is used in the case of a silent error whereby the
 487          caller may optionally want to issue the message.  */
 488       if (gdberrmsg != NULL)
 489         {
 490           if (exception.message != NULL)
 491             *gdberrmsg = xstrdup (exception.message);
 492           else
 493             *gdberrmsg = NULL;
 494         }
 495       return exception.reason;
 496     }
 497   return val;
 498 }
 499
 500 int
 501 catch_errors (catch_errors_ftype *func, void *func_args, char *errstring,
 502               return_mask mask)
 503 {
 504   volatile int val = 0;
 505   volatile struct exception exception;
 506   SIGJMP_BUF *catch = catcher_init (uiout, errstring, &exception, mask);
 507   /* This illustrates how it is possible to nest the mechanism and
 508      hence catch "break".  Of course this doesn't address the need to
 509      also catch "return".  */
 510   for (SIGSETJMP ((*catch)); catcher_state_machine (CATCH_ITER);)
 511     val = func (func_args);
 512   print_any_exception (gdb_stderr, errstring, exception);
 513   if (exception.reason != 0)
 514     return 0;
 515   return val;
 516 }
 517
 518 struct captured_command_args
 519   {
 520     catch_command_errors_ftype *command;
 521     char *arg;
 522     int from_tty;
 523   };
 524
 525 static int
 526 do_captured_command (void *data)
 527 {
 528   struct captured_command_args *context = data;
 529   context->command (context->arg, context->from_tty);
 530   /* FIXME: cagney/1999-11-07: Technically this do_cleanups() call
 531      isn't needed.  Instead an assertion check could be made that
 532      simply confirmed that the called function correctly cleaned up
 533      after itself.  Unfortunately, old code (prior to 1999-11-04) in
 534      main.c was calling SET_TOP_LEVEL(), calling the command function,
 535      and then *always* calling do_cleanups().  For the moment we
 536      remain ``bug compatible'' with that old code..  */
 537   do_cleanups (ALL_CLEANUPS);
 538   return 1;
 539 }
 540
 541 int
 542 catch_command_errors (catch_command_errors_ftype * command,
 543                       char *arg, int from_tty, return_mask mask)
 544 {
 545   struct captured_command_args args;
 546   args.command = command;
 547   args.arg = arg;
 548   args.from_tty = from_tty;
 549   return catch_errors (do_captured_command, &args, "", mask);
 550 }