/* 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, 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.
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,
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 <http://www.gnu.org/licenses/>. */
#include "defs.h"
#include "exceptions.h"
-#include <setjmp.h>
#include "breakpoint.h"
#include "target.h"
#include "inferior.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 };
-
-/* One should use catch_errors rather than manipulating these
- directly. */
-#if defined(HAVE_SIGSETJMP)
-#define SIGJMP_BUF sigjmp_buf
-#define SIGSETJMP(buf) sigsetjmp((buf), 1)
-#define SIGLONGJMP(buf,val) siglongjmp((buf), (val))
-#else
-#define SIGJMP_BUF jmp_buf
-#define SIGSETJMP(buf) setjmp(buf)
-#define SIGLONGJMP(buf,val) longjmp((buf), (val))
-#endif
+const struct gdb_exception exception_none = { 0, GDB_NO_ERROR, NULL };
/* Possible catcher states. */
enum catcher_state {
{
enum catcher_state state;
/* Jump buffer pointing back at the exception handler. */
- SIGJMP_BUF buf;
+ EXCEPTIONS_SIGJMP_BUF buf;
/* Status buffer belonging to the exception handler. */
- volatile struct exception *exception;
- /* Should the error / quit message be printed? Old code assumes
- that this file prints the error/quit message when first reported.
- New code instead directly handles the printing of error/quit
- messages. */
- int print_message;
+ volatile struct gdb_exception *exception;
/* Saved/current state. */
int mask;
- char *saved_error_pre_print;
- char *saved_quit_pre_print;
struct ui_out *saved_uiout;
struct cleanup *saved_cleanup_chain;
/* Back link. */
/* Where to go for throw_exception(). */
static struct catcher *current_catcher;
-static SIGJMP_BUF *
-catcher_init (struct ui_out *func_uiout,
- char *errstring,
- volatile struct exception *exception,
- return_mask mask,
- int print_message)
+EXCEPTIONS_SIGJMP_BUF *
+exceptions_state_mc_init (struct ui_out *func_uiout,
+ volatile struct gdb_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->error = GDB_NO_ERROR;
exception->message = NULL;
new_catcher->exception = exception;
new_catcher->mask = mask;
- new_catcher->print_message = print_message;
-
- /* Override error/quit messages during FUNC. */
- new_catcher->saved_error_pre_print = error_pre_print;
- new_catcher->saved_quit_pre_print = quit_pre_print;
- if (mask & RETURN_MASK_ERROR)
- error_pre_print = errstring;
- if (mask & RETURN_MASK_QUIT)
- quit_pre_print = errstring;
/* Override the global ``struct ui_out'' builder. */
new_catcher->saved_uiout = uiout;
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
uiout = old_catcher->saved_uiout;
- quit_pre_print = old_catcher->saved_quit_pre_print;
- error_pre_print = old_catcher->saved_error_pre_print;
-
xfree (old_catcher);
}
/* Catcher state machine. Returns non-zero if the m/c should be run
again, zero if it should abort. */
-int
-catcher_state_machine (enum catcher_action action)
+static int
+exceptions_state_mc (enum catcher_action action)
{
switch (current_catcher->state)
{
current_catcher->state = CATCHER_RUNNING;
return 1;
default:
- internal_error (__FILE__, __LINE__, "bad state");
+ internal_error (__FILE__, __LINE__, _("bad state"));
}
case CATCHER_RUNNING:
switch (action)
/* See also throw_exception. */
return 1;
default:
- internal_error (__FILE__, __LINE__, "bad switch");
+ internal_error (__FILE__, __LINE__, _("bad switch"));
}
case CATCHER_RUNNING_1:
switch (action)
/* See also throw_exception. */
return 1;
default:
- internal_error (__FILE__, __LINE__, "bad switch");
+ internal_error (__FILE__, __LINE__, _("bad switch"));
}
case CATCHER_ABORTING:
switch (action)
{
case CATCH_ITER:
{
- struct exception exception = *current_catcher->exception;
+ struct gdb_exception exception = *current_catcher->exception;
+
if (current_catcher->mask & RETURN_MASK (exception.reason))
{
/* Exit normally if this catcher can handle this
throw_exception (exception);
}
default:
- internal_error (__FILE__, __LINE__, "bad state");
+ internal_error (__FILE__, __LINE__, _("bad state"));
}
default:
- internal_error (__FILE__, __LINE__, "bad switch");
+ 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
+throw_exception (struct gdb_exception exception)
{
+ struct thread_info *tp = NULL;
+
quit_flag = 0;
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). */
- bpstat_clear_actions (stop_bpstat); /* Clear queued breakpoint commands */
+ if (tp != NULL)
+ bpstat_clear_actions (tp->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);
-
- if (annotation_level > 1)
- switch (exception.reason)
- {
- case RETURN_QUIT:
- annotate_quit ();
- break;
- case RETURN_ERROR:
- /* Assume that these are all errors. */
- annotate_error ();
- break;
- default:
- internal_error (__FILE__, __LINE__, "Bad switch.");
- }
/* 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. */
- catcher_state_machine (CATCH_THROWING);
+ exceptions_state_mc (CATCH_THROWING);
*current_catcher->exception = exception;
- SIGLONGJMP (current_catcher->buf, exception.reason);
+ EXCEPTIONS_SIGLONGJMP (current_catcher->buf, exception.reason);
}
static char *last_message;
-NORETURN void
-throw_reason (enum return_reason reason)
+void
+deprecated_throw_reason (enum return_reason reason)
{
- struct exception exception;
+ struct gdb_exception exception;
+
memset (&exception, 0, sizeof exception);
exception.reason = reason;
break;
case RETURN_ERROR:
exception.error = GENERIC_ERROR;
- exception.message = last_message;
break;
default:
- internal_error (__FILE__, __LINE__, "bad switch");
+ internal_error (__FILE__, __LINE__, _("bad switch"));
}
throw_exception (exception);
}
static void
-do_write (void *data, const char *buffer, long length_buffer)
+print_flush (void)
{
- ui_file_write (data, buffer, length_buffer);
+ struct serial *gdb_stdout_serial;
+
+ if (deprecated_error_begin_hook)
+ deprecated_error_begin_hook ();
+ 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
+ some of these should be changed to flush the lower-level ones
+ too): */
+
+ /* 1. The _filtered buffer. */
+ wrap_here ("");
+
+ /* 2. The stdio buffer. */
+ gdb_flush (gdb_stdout);
+ gdb_flush (gdb_stderr);
+
+ /* 3. The system-level buffer. */
+ gdb_stdout_serial = serial_fdopen (1);
+ 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 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');
+ if (end == NULL)
+ fputs_filtered (start, file);
+ else
+ {
+ end++;
+ ui_file_write (file, start, end - start);
+ }
+ }
+ fprintf_filtered (file, "\n");
+
+ /* Now append the annotation. */
+ switch (e.reason)
+ {
+ case RETURN_QUIT:
+ annotate_quit ();
+ break;
+ case RETURN_ERROR:
+ /* Assume that these are all errors. */
+ annotate_error ();
+ break;
+ default:
+ internal_error (__FILE__, __LINE__, _("Bad switch."));
+ }
+}
void
-exception_print (struct ui_file *file, const char *pre_print,
- struct exception e)
+exception_print (struct ui_file *file, struct gdb_exception e)
{
if (e.reason < 0 && e.message != NULL)
{
- target_terminal_ours ();
- wrap_here (""); /* Force out any buffered output */
- gdb_flush (file);
- annotate_error_begin ();
- if (pre_print)
- fputs_filtered (pre_print, file);
-
- /* 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');
- if (end == NULL)
- fputs_filtered (start, file);
- else
- {
- end++;
- ui_file_write (file, start, end - start);
- }
- }
- }
- fprintf_filtered (file, "\n");
+ print_flush ();
+ print_exception (file, e);
}
}
-NORETURN static void
-print_and_throw (enum return_reason reason, enum errors error,
- const char *prefix, const char *fmt,
- va_list ap) ATTR_NORETURN;
-NORETURN static void
-print_and_throw (enum return_reason reason, enum errors error,
- const char *prefix, const char *fmt, va_list ap)
+void
+exception_fprintf (struct ui_file *file, struct gdb_exception e,
+ const char *prefix, ...)
{
- /* FIXME: cagney/2005-01-13: While xstrvprintf is simpler it alters
- GDB's output. Instead of the message being printed
- line-at-a-time the message comes out all at once. The problem is
- that the MI testsuite is checks for line-at-a-time messages and
- changing this behavior means updating the testsuite. */
-
- struct exception e;
- struct ui_file *tmp_stream;
- long len;
-
- /* Convert the message into a print stream. */
- tmp_stream = mem_fileopen ();
- make_cleanup_ui_file_delete (tmp_stream);
- vfprintf_unfiltered (tmp_stream, fmt, ap);
-
- /* Save the message. */
- xfree (last_message);
- last_message = ui_file_xstrdup (tmp_stream, &len);
-
- /* Print the mesage to stderr, but only if the catcher isn't going
- to handle/print it locally. */
- if (current_catcher->print_message)
+ if (e.reason < 0 && e.message != NULL)
{
- if (deprecated_error_begin_hook)
- deprecated_error_begin_hook ();
+ va_list args;
+
+ print_flush ();
- /* Write the message plus any pre_print to gdb_stderr. */
+ /* Print the prefix. */
+ va_start (args, prefix);
+ vfprintf_filtered (file, prefix, args);
+ va_end (args);
+
+ print_exception (file, e);
+ }
+}
+
+static void
+print_any_exception (struct ui_file *file, const char *prefix,
+ struct gdb_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 ();
- if (error_pre_print)
- fputs_filtered (error_pre_print, gdb_stderr);
- ui_file_put (tmp_stream, do_write, gdb_stderr);
- fprintf_filtered (gdb_stderr, "\n");
+
+ /* Print the prefix. */
+ if (prefix != NULL && prefix[0] != '\0')
+ fputs_filtered (prefix, file);
+ print_exception (file, e);
}
+}
- /* Throw the exception. */
+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;
+
+ /* 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
+void
throw_verror (enum errors error, const char *fmt, va_list ap)
{
- print_and_throw (RETURN_ERROR, error, error_pre_print, fmt, ap);
+ throw_it (RETURN_ERROR, error, fmt, ap);
}
-NORETURN void
+void
throw_vfatal (const char *fmt, va_list ap)
{
- print_and_throw (RETURN_QUIT, NO_ERROR, quit_pre_print, fmt, ap);
+ throw_it (RETURN_QUIT, GDB_NO_ERROR, fmt, ap);
}
-NORETURN void
+void
throw_error (enum errors error, const char *fmt, ...)
{
va_list args;
+
va_start (args, fmt);
- print_and_throw (RETURN_ERROR, error, error_pre_print, fmt, args);
+ 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.
+/* 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.
+
+ 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
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? */
-
int
catch_exceptions (struct ui_out *uiout,
catch_exceptions_ftype *func,
void *func_args,
- char *errstring,
return_mask mask)
{
- return catch_exceptions_with_msg (uiout, func, func_args, errstring,
- NULL, mask);
+ return catch_exceptions_with_msg (uiout, func, func_args, NULL, mask);
}
-struct exception
+struct gdb_exception
catch_exception (struct ui_out *uiout,
catch_exception_ftype *func,
void *func_args,
return_mask mask)
{
- volatile struct exception exception;
- SIGJMP_BUF *catch;
- catch = catcher_init (uiout, NULL, &exception, mask, 0);
- for (SIGSETJMP ((*catch));
- catcher_state_machine (CATCH_ITER);)
- (*func) (uiout, func_args);
+ volatile struct gdb_exception exception;
+
+ TRY_CATCH (exception, mask)
+ {
+ (*func) (uiout, func_args);
+ }
return exception;
}
catch_exceptions_with_msg (struct ui_out *uiout,
catch_exceptions_ftype *func,
void *func_args,
- char *errstring,
char **gdberrmsg,
return_mask mask)
{
- volatile struct exception exception;
+ volatile struct gdb_exception exception;
volatile int val = 0;
- SIGJMP_BUF *catch = catcher_init (uiout, errstring, &exception, mask, 1);
- for (SIGSETJMP ((*catch)); catcher_state_machine (CATCH_ITER);)
- val = (*func) (uiout, func_args);
+
+ TRY_CATCH (exception, mask)
+ {
+ val = (*func) (uiout, func_args);
+ }
+ print_any_exception (gdb_stderr, NULL, exception);
gdb_assert (val >= 0);
gdb_assert (exception.reason <= 0);
if (exception.reason < 0)
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;
- SIGJMP_BUF *catch = catcher_init (uiout, errstring, &exception, mask, 1);
- /* This illustrates how it is possible to nest the mechanism and
- hence catch "break". Of course this doesn't address the need to
- also catch "return". */
- for (SIGSETJMP ((*catch)); catcher_state_machine (CATCH_ITER);)
- val = func (func_args);
+ volatile struct gdb_exception exception;
+
+ TRY_CATCH (exception, mask)
+ {
+ val = func (func_args);
+ }
+ print_any_exception (gdb_stderr, errstring, exception);
if (exception.reason != 0)
return 0;
return val;
}
-struct captured_command_args
- {
- catch_command_errors_ftype *command;
- char *arg;
- int from_tty;
- };
-
-static int
-do_captured_command (void *data)
-{
- struct captured_command_args *context = data;
- context->command (context->arg, context->from_tty);
- /* FIXME: cagney/1999-11-07: Technically this do_cleanups() call
- isn't needed. Instead an assertion check could be made that
- simply confirmed that the called function correctly cleaned up
- after itself. Unfortunately, old code (prior to 1999-11-04) in
- main.c was calling SET_TOP_LEVEL(), calling the command function,
- and then *always* calling do_cleanups(). For the moment we
- remain ``bug compatible'' with that old code.. */
- do_cleanups (ALL_CLEANUPS);
- return 1;
-}
-
int
catch_command_errors (catch_command_errors_ftype * command,
char *arg, int from_tty, return_mask mask)
{
- struct captured_command_args args;
- args.command = command;
- args.arg = arg;
- args.from_tty = from_tty;
- return catch_errors (do_captured_command, &args, "", 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;
}