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