X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fexceptions.c;h=ca80893732127057c3144c5f14fe5b4fcabbc437;hb=9f1b45b0da430a7a7abf9e54acbe6f2ef9d3a763;hp=bf042adfd8d742114432beddfd2e71cd8e328e29;hpb=16c381f0589cead48e7e707c6584ec8629601aad;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/exceptions.c b/gdb/exceptions.c index bf042adfd8..ca80893732 100644 --- a/gdb/exceptions.c +++ b/gdb/exceptions.c @@ -1,8 +1,6 @@ /* Exception (throw catch) mechanism, for GDB, the GNU debugger. - Copyright (C) 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, - 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, - 2009, 2010 Free Software Foundation, Inc. + Copyright (C) 1986-2014 Free Software Foundation, Inc. This file is part of GDB. @@ -27,7 +25,7 @@ #include "annotate.h" #include "ui-out.h" #include "gdb_assert.h" -#include "gdb_string.h" +#include #include "serial.h" #include "gdbthread.h" @@ -60,7 +58,6 @@ struct catcher volatile struct gdb_exception *exception; /* Saved/current state. */ int mask; - struct ui_out *saved_uiout; struct cleanup *saved_cleanup_chain; /* Back link. */ struct catcher *prev; @@ -69,12 +66,27 @@ struct catcher /* Where to go for throw_exception(). */ static struct catcher *current_catcher; +/* Return length of current_catcher list. */ + +static int +catcher_list_size (void) +{ + int size; + struct catcher *catcher; + + for (size = 0, catcher = current_catcher; + catcher != NULL; + catcher = catcher->prev) + ++size; + + return size; +} + EXCEPTIONS_SIGJMP_BUF * -exceptions_state_mc_init (struct ui_out *func_uiout, - volatile struct gdb_exception *exception, +exceptions_state_mc_init (volatile struct gdb_exception *exception, return_mask mask) { - struct catcher *new_catcher = XZALLOC (struct catcher); + struct catcher *new_catcher = XCNEW (struct catcher); /* Start with no exception, save it's address. */ exception->reason = 0; @@ -84,12 +96,8 @@ exceptions_state_mc_init (struct ui_out *func_uiout, 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. */ + prior to here. */ new_catcher->saved_cleanup_chain = save_cleanups (); /* Push this new catcher on the top. */ @@ -108,12 +116,10 @@ catcher_pop (void) current_catcher = old_catcher->prev; /* Restore the cleanup chain, the error/quit messages, and the uiout - builder, to their original states. */ + builder, to their original states. */ restore_cleanups (old_catcher->saved_cleanup_chain); - uiout = old_catcher->saved_uiout; - xfree (old_catcher); } @@ -186,7 +192,7 @@ exceptions_state_mc (enum catcher_action action) } /* The caller didn't request that the event be caught, relay the event to the next containing - catch_errors(). */ + catch_errors(). */ catcher_pop (); throw_exception (exception); } @@ -215,57 +221,19 @@ exceptions_state_mc_action_iter_1 (void) void throw_exception (struct gdb_exception exception) { - struct thread_info *tp = NULL; - - quit_flag = 0; + clear_quit_flag (); immediate_quit = 0; - if (!ptid_equal (inferior_ptid, null_ptid)) - tp = find_thread_ptid (inferior_ptid); - - /* 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). */ - if (tp != NULL) - { - /* Clear queued breakpoint commands */ - bpstat_clear_actions (tp->control.stop_bpstat); - } - - disable_current_display (); - do_cleanups (ALL_CLEANUPS); + do_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. */ + 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; - -void -deprecated_throw_reason (enum return_reason reason) -{ - struct gdb_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 print_flush (void) { @@ -370,7 +338,7 @@ print_any_exception (struct ui_file *file, const char *prefix, if (e.reason < 0 && e.message != NULL) { target_terminal_ours (); - wrap_here (""); /* Force out any buffered output */ + wrap_here (""); /* Force out any buffered output. */ gdb_flush (gdb_stdout); annotate_error_begin (); @@ -381,23 +349,53 @@ print_any_exception (struct ui_file *file, const char *prefix, } } +/* A stack of exception messages. + This is needed to handle nested calls to throw_it: we don't want to + xfree space for a message before it's used. + This can happen if we throw an exception during a cleanup: + An outer TRY_CATCH may have an exception message it wants to print, + but while doing cleanups further calls to throw_it are made. + + This is indexed by the size of the current_catcher list. + It is a dynamically allocated array so that we don't care how deeply + GDB nests its TRY_CATCHs. */ +static char **exception_messages; + +/* The number of currently allocated entries in exception_messages. */ +static int exception_messages_size; + static void ATTRIBUTE_NORETURN ATTRIBUTE_PRINTF (3, 0) throw_it (enum return_reason reason, enum errors error, const char *fmt, va_list ap) { struct gdb_exception e; char *new_message; + int depth = catcher_list_size (); - /* Save the message. Create the new message before deleting the - old, the new message may include the old message text. */ + gdb_assert (depth > 0); + + /* Note: The new message may use an old message's text. */ new_message = xstrvprintf (fmt, ap); - xfree (last_message); - last_message = new_message; + + if (depth > exception_messages_size) + { + int old_size = exception_messages_size; + + exception_messages_size = depth + 10; + exception_messages = (char **) xrealloc (exception_messages, + exception_messages_size + * sizeof (char *)); + memset (exception_messages + old_size, 0, + (exception_messages_size - old_size) * sizeof (char *)); + } + + xfree (exception_messages[depth - 1]); + exception_messages[depth - 1] = new_message; /* Create the exception. */ e.reason = reason; e.error = error; - e.message = last_message; + e.message = new_message; /* Throw the exception. */ throw_exception (e); @@ -442,12 +440,12 @@ throw_error (enum errors error, const char *fmt, ...) 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. */ + initialized the longjmp buffers. */ int catch_exceptions (struct ui_out *uiout, @@ -458,23 +456,8 @@ catch_exceptions (struct ui_out *uiout, return catch_exceptions_with_msg (uiout, func, func_args, NULL, mask); } -struct gdb_exception -catch_exception (struct ui_out *uiout, - catch_exception_ftype *func, - void *func_args, - return_mask mask) -{ - volatile struct gdb_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, @@ -482,11 +465,27 @@ catch_exceptions_with_msg (struct ui_out *uiout, { volatile struct gdb_exception exception; volatile int val = 0; + struct ui_out *saved_uiout; - TRY_CATCH (exception, mask) + /* 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) (current_uiout, func_args); + } + + /* Restore the global builder. */ + current_uiout = saved_uiout; + + if (exception.reason < 0 && (mask & RETURN_MASK (exception.reason)) == 0) { - val = (*func) (uiout, func_args); + /* The caller didn't request that the event be caught. + Rethrow. */ + throw_exception (exception); } + print_any_exception (gdb_stderr, NULL, exception); gdb_assert (val >= 0); gdb_assert (exception.reason <= 0); @@ -515,11 +514,26 @@ catch_errors (catch_errors_ftype *func, void *func_args, char *errstring, { volatile int val = 0; volatile struct gdb_exception exception; + struct ui_out *saved_uiout; - TRY_CATCH (exception, mask) + /* Save the global ``struct ui_out'' builder. */ + saved_uiout = current_uiout; + + TRY_CATCH (exception, RETURN_MASK_ALL) { val = func (func_args); } + + /* 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); + } + print_any_exception (gdb_stderr, errstring, exception); if (exception.reason != 0) return 0; @@ -527,7 +541,7 @@ catch_errors (catch_errors_ftype *func, void *func_args, char *errstring, } int -catch_command_errors (catch_command_errors_ftype * command, +catch_command_errors (catch_command_errors_ftype *command, char *arg, int from_tty, return_mask mask) { volatile struct gdb_exception e; @@ -541,3 +555,19 @@ catch_command_errors (catch_command_errors_ftype * command, return 0; return 1; } + +int +catch_command_errors_const (catch_command_errors_const_ftype *command, + const char *arg, int from_tty, return_mask mask) +{ + volatile struct gdb_exception e; + + TRY_CATCH (e, mask) + { + command (arg, from_tty); + } + print_any_exception (gdb_stderr, NULL, e); + if (e.reason < 0) + return 0; + return 1; +}