/* 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 Free Software
- Foundation, Inc.
+ Copyright (C) 1986-2019 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 "annotate.h"
#include "ui-out.h"
-#include "gdb_assert.h"
+#include "serial.h"
+#include "gdbthread.h"
+#include "top.h"
+#include "gdbsupport/gdb_optional.h"
-/* 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
-
-/* Where to go for throw_exception(). */
-static SIGJMP_BUF *catch_return;
-
-/* Return for reason REASON to the nearest containing catch_errors(). */
-
-NORETURN void
-throw_exception (enum return_reason reason)
+static void
+print_flush (void)
{
- quit_flag = 0;
- immediate_quit = 0;
+ struct ui *ui = current_ui;
+ struct serial *gdb_stdout_serial;
+
+ if (deprecated_error_begin_hook)
+ deprecated_error_begin_hook ();
+
+ 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 ();
+ }
- /* 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 */
+ /* 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): */
- 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);
+ /* 1. The _filtered buffer. */
+ if (filtered_printing_initialized ())
+ wrap_here ("");
- if (annotation_level > 1)
- switch (reason)
- {
- case RETURN_QUIT:
- annotate_quit ();
- break;
- case RETURN_ERROR:
- annotate_error ();
- break;
- }
+ /* 2. The stdio buffer. */
+ gdb_flush (gdb_stdout);
+ gdb_flush (gdb_stderr);
- /* 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. */
+ /* 3. The system-level buffer. */
+ gdb_stdout_serial = serial_fdopen (fileno (ui->outstream));
+ if (gdb_stdout_serial)
+ {
+ serial_drain_output (gdb_stdout_serial);
+ serial_un_fdopen (gdb_stdout_serial);
+ }
- (NORETURN void) SIGLONGJMP (*catch_return, (int) reason);
+ annotate_error_begin ();
}
-/* 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.
-
- 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. */
-
-/* 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. */
-
-/* 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? */
-
static void
-catcher (catch_exceptions_ftype *func,
- struct ui_out *func_uiout,
- void *func_args,
- int *func_val,
- enum return_reason *func_caught,
- char *errstring,
- char **gdberrmsg,
- return_mask mask)
+print_exception (struct ui_file *file, const struct gdb_exception &e)
{
- SIGJMP_BUF *saved_catch;
- SIGJMP_BUF catch;
- struct cleanup *saved_cleanup_chain;
- char *saved_error_pre_print;
- char *saved_quit_pre_print;
- struct ui_out *saved_uiout;
+ /* 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;
- /* Return value from SIGSETJMP(): enum return_reason if error or
- quit caught, 0 otherwise. */
- int caught;
-
- /* Return value from FUNC(): Hopefully non-zero. Explicitly set to
- zero if an error quit was caught. */
- int val;
-
- /* Override error/quit messages during FUNC. */
-
- saved_error_pre_print = error_pre_print;
- 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. */
-
- saved_uiout = uiout;
- uiout = func_uiout;
-
- /* Prevent error/quit during FUNC from calling cleanups established
- prior to here. */
-
- saved_cleanup_chain = save_cleanups ();
-
- /* Call FUNC, catching error/quit events. */
-
- saved_catch = catch_return;
- catch_return = &catch;
- caught = SIGSETJMP (catch);
- if (!caught)
- val = (*func) (func_uiout, func_args);
- else
+ for (start = e.what (); start != NULL; start = end)
{
- val = 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)
- *gdberrmsg = error_last_message ();
- }
- catch_return = saved_catch;
-
- /* FIXME: cagney/1999-11-05: A correct FUNC implementation will
- clean things up (restoring the cleanup chain) to the state they
- were just prior to the call. Unfortunately, many FUNC's are not
- that well behaved. This could be fixed by adding either a
- do_cleanups call (to cover the problem) or an assertion check to
- detect bad FUNCs code. */
-
- /* Restore the cleanup chain, the error/quit messages, and the uiout
- builder, to their original states. */
-
- restore_cleanups (saved_cleanup_chain);
-
- uiout = saved_uiout;
-
- if (mask & RETURN_MASK_QUIT)
- quit_pre_print = saved_quit_pre_print;
- if (mask & RETURN_MASK_ERROR)
- error_pre_print = saved_error_pre_print;
-
- /* Return normally if no error/quit event occurred or this catcher
- can handle this exception. The caller analyses the func return
- values. */
-
- if (!caught || (mask & RETURN_MASK (caught)))
+ 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)
{
- *func_val = val;
- *func_caught = caught;
- return;
+ 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."));
}
-
- /* The caller didn't request that the event be caught, relay the
- event to the next containing catch_errors(). */
-
- throw_exception (caught);
}
-int
-catch_exceptions (struct ui_out *uiout,
- catch_exceptions_ftype *func,
- void *func_args,
- char *errstring,
- return_mask mask)
+void
+exception_print (struct ui_file *file, const struct gdb_exception &e)
{
- int val;
- enum return_reason caught;
- catcher (func, uiout, func_args, &val, &caught, errstring, NULL, mask);
- gdb_assert (val >= 0);
- gdb_assert (caught <= 0);
- if (caught < 0)
- return caught;
- return val;
+ if (e.reason < 0 && e.message != NULL)
+ {
+ print_flush ();
+ print_exception (file, e);
+ }
}
-int
-catch_exceptions_with_msg (struct ui_out *uiout,
- catch_exceptions_ftype *func,
- void *func_args,
- char *errstring,
- char **gdberrmsg,
- return_mask mask)
+void
+exception_fprintf (struct ui_file *file, const struct gdb_exception &e,
+ const char *prefix, ...)
{
- int val;
- enum return_reason caught;
- catcher (func, uiout, func_args, &val, &caught, errstring, gdberrmsg, mask);
- gdb_assert (val >= 0);
- gdb_assert (caught <= 0);
- if (caught < 0)
- return caught;
- return val;
-}
+ if (e.reason < 0 && e.message != NULL)
+ {
+ va_list args;
-struct catch_errors_args
-{
- catch_errors_ftype *func;
- void *func_args;
-};
+ print_flush ();
-static int
-do_catch_errors (struct ui_out *uiout, void *data)
-{
- struct catch_errors_args *args = data;
- return args->func (args->func_args);
-}
+ /* Print the prefix. */
+ va_start (args, prefix);
+ vfprintf_filtered (file, prefix, args);
+ va_end (args);
-int
-catch_errors (catch_errors_ftype *func, void *func_args, char *errstring,
- return_mask mask)
-{
- int val;
- enum return_reason caught;
- struct catch_errors_args args;
- args.func = func;
- args.func_args = func_args;
- catcher (do_catch_errors, uiout, &args, &val, &caught, errstring,
- NULL, mask);
- if (caught != 0)
- return 0;
- return val;
+ print_exception (file, e);
+ }
}
-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;
-}
+/* See exceptions.h. */
int
-catch_command_errors (catch_command_errors_ftype * command,
- char *arg, int from_tty, return_mask mask)
+exception_print_same (const struct gdb_exception &e1,
+ const struct gdb_exception &e2)
{
- struct captured_command_args args;
- args.command = command;
- args.arg = arg;
- args.from_tty = from_tty;
- return catch_errors (do_captured_command, &args, "", mask);
+ const char *msg1 = e1.message == nullptr ? "" : e1.what ();
+ const char *msg2 = e2.message == nullptr ? "" : e2.what ();
+
+ return (e1.reason == e2.reason
+ && e1.error == e2.error
+ && strcmp (msg1, msg2) == 0);
}