/* 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-2019 Free Software Foundation, Inc.
This file is part of GDB.
#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 gdb_exception exception_none = { 0, GDB_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 gdb_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 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 = GDB_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. */
-
- 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 gdb_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 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). */
- if (tp != NULL)
- bpstat_clear_actions (tp->stop_bpstat); /* Clear queued breakpoint commands */
-
- disable_current_display ();
- 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. */
- 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 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);
-}
+#include "top.h"
+#include "gdbsupport/gdb_optional.h"
static void
print_flush (void)
{
+ struct ui *ui = current_ui;
struct serial *gdb_stdout_serial;
if (deprecated_error_begin_hook)
deprecated_error_begin_hook ();
- target_terminal_ours ();
+
+ gdb::optional<target_terminal::scoped_restore_terminal_state> term_state;
+ /* While normally there's always something pushed on the target
+ stack, the NULL check is needed here because we can get here very
+ early during startup, before the target stack is first
+ initialized. */
+ if (current_top_target () != NULL && target_supports_terminal_ours ())
+ {
+ term_state.emplace ();
+ target_terminal::ours_for_output ();
+ }
/* 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
too): */
/* 1. The _filtered buffer. */
- wrap_here ("");
+ if (filtered_printing_initialized ())
+ 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);
+ gdb_stdout_serial = serial_fdopen (fileno (ui->outstream));
if (gdb_stdout_serial)
{
serial_drain_output (gdb_stdout_serial);
}
static void
-print_exception (struct ui_file *file, struct gdb_exception e)
+print_exception (struct ui_file *file, const 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)
+
+ for (start = e.what (); start != NULL; start = end)
{
end = strchr (start, '\n');
if (end == NULL)
}
void
-exception_print (struct ui_file *file, struct gdb_exception e)
+exception_print (struct ui_file *file, const struct gdb_exception &e)
{
if (e.reason < 0 && e.message != NULL)
{
}
void
-exception_fprintf (struct ui_file *file, struct gdb_exception e,
+exception_fprintf (struct ui_file *file, const struct gdb_exception &e,
const char *prefix, ...)
{
if (e.reason < 0 && e.message != NULL)
}
}
-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 ();
-
- /* Print the prefix. */
- if (prefix != NULL && prefix[0] != '\0')
- fputs_filtered (prefix, file);
- print_exception (file, e);
- }
-}
-
-NORETURN static void ATTR_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
-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, GDB_NO_ERROR, fmt, ap);
-}
-
-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(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. */
-
-/* MAYBE: cagney/1999-11-05: catch_errors() in conjunction with
- error() et.al. could maintain a set of flags that indicate the 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. */
+/* See exceptions.h. */
int
-catch_exceptions (struct ui_out *uiout,
- catch_exceptions_ftype *func,
- void *func_args,
- return_mask mask)
+exception_print_same (const struct gdb_exception &e1,
+ const struct gdb_exception &e2)
{
- 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;
-}
+ const char *msg1 = e1.message == nullptr ? "" : e1.what ();
+ const char *msg2 = e2.message == nullptr ? "" : e2.what ();
-int
-catch_exceptions_with_msg (struct ui_out *uiout,
- catch_exceptions_ftype *func,
- void *func_args,
- char **gdberrmsg,
- return_mask mask)
-{
- volatile struct gdb_exception exception;
- volatile int val = 0;
- 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)
- {
- /* If caller wants a copy of the low-level error message, make
- one. This is used in the case of a silent error whereby the
- caller may optionally want to issue the message. */
- if (gdberrmsg != NULL)
- {
- if (exception.message != NULL)
- *gdberrmsg = xstrdup (exception.message);
- else
- *gdberrmsg = NULL;
- }
- return exception.reason;
- }
- 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 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;
-}
-
-int
-catch_command_errors (catch_command_errors_ftype * command,
- 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;
+ return (e1.reason == e2.reason
+ && e1.error == e2.error
+ && strcmp (msg1, msg2) == 0);
}