X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Fexceptions.c;h=28b8dd1bce65e6181e93feca5005b4b543227cd4;hb=ae6a105d22fb603dbfb956bbcedf9ae469323d55;hp=610f1682d6b0f4c9c52379ebb21fe600eb712106;hpb=6941d02a18df94a250129611982bc7ab11d6124b;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/exceptions.c b/gdb/exceptions.c index 610f1682d6..28b8dd1bce 100644 --- a/gdb/exceptions.c +++ b/gdb/exceptions.c @@ -1,14 +1,12 @@ /* Exception (throw catch) mechanism, for GDB, the GNU debugger. - Copyright 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, - 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005 Free - Software Foundation, Inc. + Copyright (C) 1986-2014 Free Software Foundation, Inc. This file is part of GDB. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by - the Free Software Foundation; either version 2 of the License, or + the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, @@ -17,9 +15,7 @@ GNU General Public License for more details. You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software - Foundation, Inc., 59 Temple Place - Suite 330, - Boston, MA 02111-1307, USA. */ + along with this program. If not, see . */ #include "defs.h" #include "exceptions.h" @@ -28,235 +24,16 @@ #include "inferior.h" #include "annotate.h" #include "ui-out.h" -#include "gdb_assert.h" -#include "gdb_string.h" #include "serial.h" +#include "gdbthread.h" -const struct exception exception_none = { 0, NO_ERROR, NULL }; - -/* Possible catcher states. */ -enum catcher_state { - /* Initial state, a new catcher has just been created. */ - CATCHER_CREATED, - /* The catch code is running. */ - CATCHER_RUNNING, - CATCHER_RUNNING_1, - /* The catch code threw an exception. */ - CATCHER_ABORTING -}; - -/* Possible catcher actions. */ -enum catcher_action { - CATCH_ITER, - CATCH_ITER_1, - CATCH_THROWING -}; - -struct catcher -{ - enum catcher_state state; - /* Jump buffer pointing back at the exception handler. */ - EXCEPTIONS_SIGJMP_BUF buf; - /* Status buffer belonging to the exception handler. */ - volatile struct exception *exception; - /* Saved/current state. */ - int mask; - struct ui_out *saved_uiout; - struct cleanup *saved_cleanup_chain; - /* Back link. */ - struct catcher *prev; -}; - -/* Where to go for throw_exception(). */ -static struct catcher *current_catcher; - -EXCEPTIONS_SIGJMP_BUF * -exceptions_state_mc_init (struct ui_out *func_uiout, - volatile struct exception *exception, - return_mask mask) -{ - struct catcher *new_catcher = XZALLOC (struct catcher); - - /* Start with no exception, save it's address. */ - exception->reason = 0; - exception->error = NO_ERROR; - exception->message = NULL; - new_catcher->exception = exception; - - new_catcher->mask = mask; - - /* Override the global ``struct ui_out'' builder. */ - new_catcher->saved_uiout = uiout; - uiout = func_uiout; - - /* Prevent error/quit during FUNC from calling cleanups established - prior to here. */ - new_catcher->saved_cleanup_chain = save_cleanups (); - - /* Push this new catcher on the top. */ - new_catcher->prev = current_catcher; - current_catcher = new_catcher; - new_catcher->state = CATCHER_CREATED; - - return &new_catcher->buf; -} - -static void -catcher_pop (void) -{ - struct catcher *old_catcher = current_catcher; - current_catcher = old_catcher->prev; - - /* Restore the cleanup chain, the error/quit messages, and the uiout - builder, to their original states. */ +const struct gdb_exception exception_none = { 0, GDB_NO_ERROR, NULL }; - restore_cleanups (old_catcher->saved_cleanup_chain); - - uiout = old_catcher->saved_uiout; - - xfree (old_catcher); -} - -/* Catcher state machine. Returns non-zero if the m/c should be run - again, zero if it should abort. */ - -static int -exceptions_state_mc (enum catcher_action action) -{ - switch (current_catcher->state) - { - case CATCHER_CREATED: - switch (action) - { - case CATCH_ITER: - /* Allow the code to run the catcher. */ - current_catcher->state = CATCHER_RUNNING; - return 1; - default: - internal_error (__FILE__, __LINE__, "bad state"); - } - case CATCHER_RUNNING: - switch (action) - { - case CATCH_ITER: - /* No error/quit has occured. Just clean up. */ - catcher_pop (); - return 0; - case CATCH_ITER_1: - current_catcher->state = CATCHER_RUNNING_1; - return 1; - case CATCH_THROWING: - current_catcher->state = CATCHER_ABORTING; - /* See also throw_exception. */ - return 1; - default: - internal_error (__FILE__, __LINE__, "bad switch"); - } - case CATCHER_RUNNING_1: - switch (action) - { - case CATCH_ITER: - /* The did a "break" from the inner while loop. */ - catcher_pop (); - return 0; - case CATCH_ITER_1: - current_catcher->state = CATCHER_RUNNING; - return 0; - case CATCH_THROWING: - current_catcher->state = CATCHER_ABORTING; - /* See also throw_exception. */ - return 1; - default: - internal_error (__FILE__, __LINE__, "bad switch"); - } - case CATCHER_ABORTING: - switch (action) - { - case CATCH_ITER: - { - struct exception exception = *current_catcher->exception; - if (current_catcher->mask & RETURN_MASK (exception.reason)) - { - /* Exit normally if this catcher can handle this - exception. The caller analyses the func return - values. */ - catcher_pop (); - return 0; - } - /* The caller didn't request that the event be caught, - relay the event to the next containing - catch_errors(). */ - catcher_pop (); - throw_exception (exception); - } - default: - internal_error (__FILE__, __LINE__, "bad state"); - } - default: - internal_error (__FILE__, __LINE__, "bad switch"); - } -} - -int -exceptions_state_mc_action_iter (void) -{ - return exceptions_state_mc (CATCH_ITER); -} - -int -exceptions_state_mc_action_iter_1 (void) -{ - return exceptions_state_mc (CATCH_ITER_1); -} - -/* Return EXCEPTION to the nearest containing catch_errors(). */ - -NORETURN void -throw_exception (struct exception exception) +void +prepare_to_throw_exception (void) { - quit_flag = 0; + clear_quit_flag (); immediate_quit = 0; - - /* Perhaps it would be cleaner to do this via the cleanup chain (not sure - I can think of a reason why that is vital, though). */ - bpstat_clear_actions (stop_bpstat); /* Clear queued breakpoint commands */ - - disable_current_display (); - do_cleanups (ALL_CLEANUPS); - if (target_can_async_p () && !target_executing) - do_exec_cleanups (ALL_CLEANUPS); - if (sync_execution) - do_exec_error_cleanups (ALL_CLEANUPS); - - /* Jump to the containing catch_errors() call, communicating REASON - to that call via setjmp's return value. Note that REASON can't - be zero, by definition in defs.h. */ - exceptions_state_mc (CATCH_THROWING); - *current_catcher->exception = exception; - EXCEPTIONS_SIGLONGJMP (current_catcher->buf, exception.reason); -} - -static char *last_message; - -NORETURN void -deprecated_throw_reason (enum return_reason reason) -{ - struct exception exception; - memset (&exception, 0, sizeof exception); - - exception.reason = reason; - switch (reason) - { - case RETURN_QUIT: - break; - case RETURN_ERROR: - exception.error = GENERIC_ERROR; - break; - default: - internal_error (__FILE__, __LINE__, "bad switch"); - } - - throw_exception (exception); } static void @@ -266,7 +43,9 @@ print_flush (void) if (deprecated_error_begin_hook) deprecated_error_begin_hook (); - target_terminal_ours (); + + if (target_supports_terminal_ours ()) + target_terminal_ours (); /* We want all output to appear now, before we print the error. We have 3 levels of buffering we have to flush (it's possible that @@ -274,7 +53,8 @@ print_flush (void) too): */ /* 1. The _filtered buffer. */ - wrap_here (""); + if (filtered_printing_initialized ()) + wrap_here (""); /* 2. The stdio buffer. */ gdb_flush (gdb_stdout); @@ -282,19 +62,23 @@ print_flush (void) /* 3. The system-level buffer. */ gdb_stdout_serial = serial_fdopen (1); - serial_drain_output (gdb_stdout_serial); - serial_un_fdopen (gdb_stdout_serial); + if (gdb_stdout_serial) + { + serial_drain_output (gdb_stdout_serial); + serial_un_fdopen (gdb_stdout_serial); + } annotate_error_begin (); } static void -print_exception (struct ui_file *file, struct exception e) +print_exception (struct ui_file *file, struct gdb_exception e) { /* KLUGE: cagney/2005-01-13: Write the string out one line at a time as that way the MI's behavior is preserved. */ const char *start; const char *end; + for (start = e.message; start != NULL; start = end) { end = strchr (start, '\n'); @@ -324,7 +108,7 @@ print_exception (struct ui_file *file, struct exception e) } void -exception_print (struct ui_file *file, struct exception e) +exception_print (struct ui_file *file, struct gdb_exception e) { if (e.reason < 0 && e.message != NULL) { @@ -334,7 +118,7 @@ exception_print (struct ui_file *file, struct exception e) } void -exception_fprintf (struct ui_file *file, struct exception e, +exception_fprintf (struct ui_file *file, struct gdb_exception e, const char *prefix, ...) { if (e.reason < 0 && e.message != NULL) @@ -352,101 +136,29 @@ exception_fprintf (struct ui_file *file, struct exception e, } } -void -print_any_exception (struct ui_file *file, const char *prefix, - struct exception e) -{ - if (e.reason < 0 && e.message != NULL) - { - target_terminal_ours (); - wrap_here (""); /* Force out any buffered output */ - gdb_flush (gdb_stdout); - annotate_error_begin (); - - /* Print the prefix. */ - if (prefix != NULL && prefix[0] != '\0') - fputs_filtered (prefix, file); - print_exception (file, e); - } -} - -NORETURN static void -throw_it (enum return_reason reason, enum errors error, const char *fmt, - va_list ap) ATTR_NORETURN; -NORETURN static void -throw_it (enum return_reason reason, enum errors error, const char *fmt, - va_list ap) -{ - struct exception e; - char *new_message; - - /* Save the message. Create the new message before deleting the - old, the new message may include the old message text. */ - new_message = xstrvprintf (fmt, ap); - xfree (last_message); - last_message = new_message; - - /* Create the exception. */ - e.reason = reason; - e.error = error; - e.message = last_message; - - /* Throw the exception. */ - throw_exception (e); -} - -NORETURN void -throw_verror (enum errors error, const char *fmt, va_list ap) -{ - throw_it (RETURN_ERROR, error, fmt, ap); -} - -NORETURN void -throw_vfatal (const char *fmt, va_list ap) -{ - throw_it (RETURN_QUIT, NO_ERROR, fmt, ap); -} +/* Call FUNC(UIOUT, FUNC_ARGS) but wrapped within an exception + handler. If an exception (enum return_reason) is thrown using + throw_exception() than all cleanups installed since + catch_exceptions() was entered are invoked, the (-ve) exception + value is then returned by catch_exceptions. If FUNC() returns + normally (with a positive or zero return value) then that value is + returned by catch_exceptions(). It is an internal_error() for + FUNC() to return a negative value. -NORETURN void -throw_error (enum errors error, const char *fmt, ...) -{ - va_list args; - va_start (args, fmt); - throw_it (RETURN_ERROR, error, fmt, args); - va_end (args); -} - -/* Call FUNC() with args FUNC_UIOUT and FUNC_ARGS, catching any - errors. Set FUNC_CAUGHT to an ``enum return_reason'' if the - function is aborted (using throw_exception() or zero if the - function returns normally. Set FUNC_VAL to the value returned by - the function or 0 if the function was aborted. + See exceptions.h for further usage details. Must not be called with immediate_quit in effect (bad things might happen, say we got a signal in the middle of a memcpy to quit_return). This is an OK restriction; with very few exceptions immediate_quit can - be replaced by judicious use of QUIT. - - MASK specifies what to catch; it is normally set to - RETURN_MASK_ALL, if for no other reason than that the code which - calls catch_errors might not be set up to deal with a quit which - isn't caught. But if the code can deal with it, it generally - should be RETURN_MASK_ERROR, unless for some reason it is more - useful to abort only the portion of the operation inside the - catch_errors. Note that quit should return to the command line - fairly quickly, even if some further processing is being done. */ + be replaced by judicious use of QUIT. */ /* MAYBE: cagney/1999-11-05: catch_errors() in conjunction with - error() et.al. could maintain a set of flags that indicate the the + error() et al. could maintain a set of flags that indicate the current state of each of the longjmp buffers. This would give the longjmp code the chance to detect a longjmp botch (before it gets to longjmperror()). Prior to 1999-11-05 this wasn't possible as code also randomly used a SET_TOP_LEVEL macro that directly - initialize the longjmp buffers. */ - -/* MAYBE: cagney/1999-11-05: Should the catch_errors and cleanups code - be consolidated into a single file instead of being distributed - between utils.c and top.c? */ + initialized the longjmp buffers. */ int catch_exceptions (struct ui_out *uiout, @@ -457,34 +169,37 @@ catch_exceptions (struct ui_out *uiout, return catch_exceptions_with_msg (uiout, func, func_args, NULL, mask); } -struct exception -catch_exception (struct ui_out *uiout, - catch_exception_ftype *func, - void *func_args, - return_mask mask) -{ - volatile struct exception exception; - TRY_CATCH (exception, mask) - { - (*func) (uiout, func_args); - } - return exception; -} - int -catch_exceptions_with_msg (struct ui_out *uiout, +catch_exceptions_with_msg (struct ui_out *func_uiout, catch_exceptions_ftype *func, void *func_args, char **gdberrmsg, return_mask mask) { - volatile struct exception exception; + volatile struct gdb_exception exception; volatile int val = 0; - TRY_CATCH (exception, mask) + struct ui_out *saved_uiout; + + /* Save and override the global ``struct ui_out'' builder. */ + saved_uiout = current_uiout; + current_uiout = func_uiout; + + TRY_CATCH (exception, RETURN_MASK_ALL) { - val = (*func) (uiout, func_args); + val = (*func) (current_uiout, func_args); } - print_any_exception (gdb_stderr, NULL, exception); + + /* Restore the global builder. */ + current_uiout = saved_uiout; + + if (exception.reason < 0 && (mask & RETURN_MASK (exception.reason)) == 0) + { + /* The caller didn't request that the event be caught. + Rethrow. */ + throw_exception (exception); + } + + exception_print (gdb_stderr, exception); gdb_assert (val >= 0); gdb_assert (exception.reason <= 0); if (exception.reason < 0) @@ -504,33 +219,36 @@ catch_exceptions_with_msg (struct ui_out *uiout, return val; } +/* This function is superseded by catch_exceptions(). */ + int catch_errors (catch_errors_ftype *func, void *func_args, char *errstring, return_mask mask) { volatile int val = 0; - volatile struct exception exception; - TRY_CATCH (exception, mask) + volatile struct gdb_exception exception; + struct ui_out *saved_uiout; + + /* Save the global ``struct ui_out'' builder. */ + saved_uiout = current_uiout; + + TRY_CATCH (exception, RETURN_MASK_ALL) { val = func (func_args); } - print_any_exception (gdb_stderr, errstring, exception); - if (exception.reason != 0) - return 0; - return val; -} -int -catch_command_errors (catch_command_errors_ftype * command, - char *arg, int from_tty, return_mask mask) -{ - volatile struct exception e; - TRY_CATCH (e, mask) + /* Restore the global builder. */ + current_uiout = saved_uiout; + + if (exception.reason < 0 && (mask & RETURN_MASK (exception.reason)) == 0) { - command (arg, from_tty); + /* The caller didn't request that the event be caught. + Rethrow. */ + throw_exception (exception); } - print_any_exception (gdb_stderr, NULL, e); - if (e.reason < 0) + + exception_fprintf (gdb_stderr, exception, "%s", errstring); + if (exception.reason != 0) return 0; - return 1; + return val; }