/* Top level stuff for GDB, the GNU debugger.
- Copyright (C) 1999-2019 Free Software Foundation, Inc.
+ Copyright (C) 1999-2021 Free Software Foundation, Inc.
Written by Elena Zannoni <ezannoni@cygnus.com> of Cygnus Solutions.
#include "inferior.h"
#include "infrun.h"
#include "target.h"
-#include "terminal.h" /* for job_control */
-#include "event-loop.h"
+#include "terminal.h"
+#include "gdbsupport/event-loop.h"
#include "event-top.h"
#include "interps.h"
#include <signal.h>
#include "gdbcmd.h" /* for dont_repeat() */
#include "annotate.h"
#include "maint.h"
-#include "common/buffer.h"
+#include "gdbsupport/buffer.h"
#include "ser-event.h"
-#include "gdb_select.h"
+#include "gdbsupport/gdb_select.h"
+#include "gdbsupport/gdb-sigmask.h"
+#include "async-event.h"
/* readline include files. */
#include "readline/readline.h"
ezannoni: as of 1999-04-29 I expect that this
variable will not be used after gdb is changed to use the event
loop as default engine, and event-top.c is merged into top.c. */
-int set_editing_cmd_var;
+bool set_editing_cmd_var;
/* This is used to display the notification of the completion of an
asynchronous execution command. */
-int exec_done_display_p = 0;
+bool exec_done_display_p = false;
/* Used by the stdin event handler to compensate for missed stdin events.
Setting this to a non-zero value inside an stdin callback makes the callback
static void
gdb_rl_callback_handler (char *rl) noexcept
{
- struct gdb_exception gdb_rl_expt;
+ /* This is static to avoid undefined behavior when calling longjmp
+ -- gdb_exception has a destructor with side effects. */
+ static struct gdb_exception gdb_rl_expt;
struct ui *ui = current_ui;
try
{
+ /* Ensure the exception is reset on each call. */
+ gdb_rl_expt = {};
ui->input_handler (gdb::unique_xmalloc_ptr<char> (rl));
}
catch (gdb_exception &ex)
else
{
/* Don't use a _filtered function here. It causes the assumed
- character position to be off, since the newline we read from
- the user is not accounted for. */
- fputs_unfiltered (actual_gdb_prompt.c_str (), gdb_stdout);
+ character position to be off, since the newline we read from
+ the user is not accounted for. */
+ fprintf_unfiltered (gdb_stdout, "%s", actual_gdb_prompt.c_str ());
gdb_flush (gdb_stdout);
}
}
/* Return the top level prompt, as specified by "set prompt", possibly
- overriden by the python gdb.prompt_hook hook, and then composed
+ overridden by the python gdb.prompt_hook hook, and then composed
with the prompt prefix and suffix (annotations). */
static std::string
void
ui_register_input_event_handler (struct ui *ui)
{
- add_file_handler (ui->input_fd, stdin_event_handler, ui);
+ add_file_handler (ui->input_fd, stdin_event_handler, ui,
+ string_printf ("ui-%d", ui->num), true);
}
/* See top.h. */
If REPEAT, handle command repetitions:
- If the input command line is NOT empty, the command returned is
- copied into the global 'saved_command_line' var so that it can
- be repeated later.
+ saved using save_command_line () so that it can be repeated later.
- - OTOH, if the input command line IS empty, return the previously
- saved command instead of the empty input line.
+ - OTOH, if the input command line IS empty, return the saved
+ command instead of the empty input line.
*/
char *
server_command = startswith (cmd, SERVER_COMMAND_PREFIX);
if (server_command)
{
- /* Note that we don't set `saved_command_line'. Between this
- and the check in dont_repeat, this insures that repeating
- will still do the right thing. */
+ /* Note that we don't call `save_command_line'. Between this
+ and the check in dont_repeat, this insures that repeating
+ will still do the right thing. */
return cmd + strlen (SERVER_COMMAND_PREFIX);
}
for (p1 = cmd; *p1 == ' ' || *p1 == '\t'; p1++)
;
if (repeat && *p1 == '\0')
- return saved_command_line;
+ return get_saved_command_line ();
/* Add command to history if appropriate. Note: lines consisting
solely of comments are also added to the command history. This
/* Save into global buffer if appropriate. */
if (repeat)
{
- xfree (saved_command_line);
- saved_command_line = xstrdup (cmd);
- return saved_command_line;
+ save_command_line (cmd);
+ return get_saved_command_line ();
}
else
return cmd;
while (1)
{
/* Read from stdin if we are executing a user defined command.
- This is the right thing for prompt_for_continue, at least. */
+ This is the right thing for prompt_for_continue, at least. */
c = fgetc (ui->instream != NULL ? ui->instream : ui->stdin_stream);
if (c == EOF)
}
\f
+/* See event-top.h. */
+
+thread_local void (*thread_local_segv_handler) (int);
+
+static void handle_sigsegv (int sig);
+
+/* Install the SIGSEGV handler. */
+static void
+install_handle_sigsegv ()
+{
+#if defined (HAVE_SIGACTION)
+ struct sigaction sa;
+ sa.sa_handler = handle_sigsegv;
+ sigemptyset (&sa.sa_mask);
+#ifdef HAVE_SIGALTSTACK
+ sa.sa_flags = SA_ONSTACK;
+#else
+ sa.sa_flags = 0;
+#endif
+ sigaction (SIGSEGV, &sa, nullptr);
+#else
+ signal (SIGSEGV, handle_sigsegv);
+#endif
+}
+
+/* Handler for SIGSEGV. */
+
+static void
+handle_sigsegv (int sig)
+{
+ install_handle_sigsegv ();
+
+ if (thread_local_segv_handler == nullptr)
+ abort (); /* ARI: abort */
+ thread_local_segv_handler (sig);
+}
+
+\f
+
/* The serial event associated with the QUIT flag. set_quit_flag sets
this, and check_quit_flag clears it. Used by interruptible_select
to be able to do interruptible I/O with no race with the SIGINT
signal (SIGINT, handle_sigint);
sigint_token =
- create_async_signal_handler (async_request_quit, NULL);
+ create_async_signal_handler (async_request_quit, NULL, "sigint");
signal (SIGTERM, handle_sigterm);
async_sigterm_token
- = create_async_signal_handler (async_sigterm_handler, NULL);
+ = create_async_signal_handler (async_sigterm_handler, NULL, "sigterm");
/* If SIGTRAP was set to SIG_IGN, then the SIG_IGN will get passed
to the inferior and breakpoints will be ignored. */
to SIG_DFL for us. */
signal (SIGQUIT, handle_sigquit);
sigquit_token =
- create_async_signal_handler (async_do_nothing, NULL);
+ create_async_signal_handler (async_do_nothing, NULL, "sigquit");
#endif
#ifdef SIGHUP
if (signal (SIGHUP, handle_sighup) != SIG_IGN)
sighup_token =
- create_async_signal_handler (async_disconnect, NULL);
+ create_async_signal_handler (async_disconnect, NULL, "sighup");
else
sighup_token =
- create_async_signal_handler (async_do_nothing, NULL);
+ create_async_signal_handler (async_do_nothing, NULL, "sighup");
#endif
signal (SIGFPE, handle_sigfpe);
sigfpe_token =
- create_async_signal_handler (async_float_handler, NULL);
+ create_async_signal_handler (async_float_handler, NULL, "sigfpe");
#ifdef SIGTSTP
sigtstp_token =
- create_async_signal_handler (async_sigtstp_handler, NULL);
+ create_async_signal_handler (async_sigtstp_handler, NULL, "sigtstp");
#endif
+
+ install_handle_sigsegv ();
}
/* See defs.h. */
exception_print (gdb_stderr, exception);
}
- try
- {
- pop_all_targets ();
- }
- catch (const gdb_exception &exception)
+ for (inferior *inf : all_inferiors ())
{
+ switch_to_inferior_no_thread (inf);
+ try
+ {
+ pop_all_targets ();
+ }
+ catch (const gdb_exception &exception)
+ {
+ }
}
signal (SIGHUP, SIG_DFL); /*FIXME: ??????????? */
sigset_t zero;
sigemptyset (&zero);
- sigprocmask (SIG_SETMASK, &zero, 0);
+ gdb_sigmask (SIG_SETMASK, &zero, 0);
}
#elif HAVE_SIGSETMASK
sigsetmask (0);
signal (sig, handle_sigfpe);
}
-/* Event loop will call this functin to process a SIGFPE. */
+/* Event loop will call this function to process a SIGFPE. */
static void
async_float_handler (gdb_client_data arg)
{
gdb_rl_callback_handler_remove ();
delete_file_handler (ui->input_fd);
}
+
+static const char debug_event_loop_off[] = "off";
+static const char debug_event_loop_all_except_ui[] = "all-except-ui";
+static const char debug_event_loop_all[] = "all";
+
+static const char *debug_event_loop_enum[] = {
+ debug_event_loop_off,
+ debug_event_loop_all_except_ui,
+ debug_event_loop_all,
+ nullptr
+};
+
+static const char *debug_event_loop_value = debug_event_loop_off;
+
+static void
+set_debug_event_loop_command (const char *args, int from_tty,
+ cmd_list_element *c)
+{
+ if (debug_event_loop_value == debug_event_loop_off)
+ debug_event_loop = debug_event_loop_kind::OFF;
+ else if (debug_event_loop_value == debug_event_loop_all_except_ui)
+ debug_event_loop = debug_event_loop_kind::ALL_EXCEPT_UI;
+ else if (debug_event_loop_value == debug_event_loop_all)
+ debug_event_loop = debug_event_loop_kind::ALL;
+ else
+ gdb_assert_not_reached ("Invalid debug event look kind value.");
+}
+
+static void
+show_debug_event_loop_command (struct ui_file *file, int from_tty,
+ struct cmd_list_element *cmd, const char *value)
+{
+ fprintf_filtered (file, _("Event loop debugging is %s.\n"), value);
+}
+
+void _initialize_event_top ();
+void
+_initialize_event_top ()
+{
+ add_setshow_enum_cmd ("event-loop", class_maintenance,
+ debug_event_loop_enum,
+ &debug_event_loop_value,
+ _("Set event-loop debugging."),
+ _("Show event-loop debugging."),
+ _("\
+Control whether to show event loop-related debug messages."),
+ set_debug_event_loop_command,
+ show_debug_event_loop_command,
+ &setdebuglist, &showdebuglist);
+}