/* Top level stuff for GDB, the GNU debugger.
- Copyright (C) 1999-2021 Free Software Foundation, Inc.
+ Copyright (C) 1999-2023 Free Software Foundation, Inc.
Written by Elena Zannoni <ezannoni@cygnus.com> of Cygnus Solutions.
#include "gdbsupport/gdb_select.h"
#include "gdbsupport/gdb-sigmask.h"
#include "async-event.h"
+#include "bt-utils.h"
+#include "pager.h"
/* readline include files. */
#include "readline/readline.h"
#ifdef SIGHUP
static void handle_sighup (int sig);
#endif
-static void handle_sigfpe (int sig);
/* Functions to be invoked by the event loop in response to
signals. */
#ifdef SIGHUP
static void async_disconnect (gdb_client_data);
#endif
-static void async_float_handler (gdb_client_data);
#ifdef SIGTSTP
static void async_sigtstp_handler (gdb_client_data);
#endif
run again. */
int call_stdin_event_handler_again_p;
+/* When true GDB will produce a minimal backtrace when a fatal signal is
+ reached (within GDB code). */
+static bool bt_on_fatal_signal = GDB_PRINT_INTERNAL_BACKTRACE_INIT_ON;
+
+/* Implement 'maintenance show backtrace-on-fatal-signal'. */
+
+static void
+show_bt_on_fatal_signal (struct ui_file *file, int from_tty,
+ struct cmd_list_element *cmd, const char *value)
+{
+ gdb_printf (file, _("Backtrace on a fatal signal is %s.\n"), value);
+}
+
/* Signal handling variables. */
/* Each of these is a pointer to a function that the event loop will
invoke if the corresponding signal has received. The real signal
#ifdef SIGQUIT
static struct async_signal_handler *sigquit_token;
#endif
-static struct async_signal_handler *sigfpe_token;
#ifdef SIGTSTP
static struct async_signal_handler *sigtstp_token;
#endif
TRY_SJLJ
{
rl_callback_read_char ();
+#if RL_VERSION_MAJOR >= 8
+ /* It can happen that readline (while in rl_callback_read_char)
+ received a signal, but didn't handle it yet. Make sure it's handled
+ now. If we don't do that we run into two related problems:
+ - we have to wait for another event triggering
+ rl_callback_read_char before the signal is handled
+ - there's no guarantee that the signal will be processed before the
+ event. */
+ while (rl_pending_signal () != 0)
+ /* Do this in a while loop, in case rl_check_signals also leaves a
+ pending signal. I'm not sure if that's possible, but it seems
+ better to handle the scenario than to assert. */
+ rl_check_signals ();
+#else
+ /* Unfortunately, rl_check_signals is not available. */
+#endif
if (after_char_processing_hook)
(*after_char_processing_hook) ();
}
is typing would lose input. */
/* Whether we've registered a callback handler with readline. */
-static int callback_handler_installed;
+static bool callback_handler_installed;
/* See event-top.h, and above. */
gdb_assert (current_ui == main_ui);
rl_callback_handler_remove ();
- callback_handler_installed = 0;
+ callback_handler_installed = false;
}
/* See event-top.h, and above. Note this wrapper doesn't have an
gdb_assert (!callback_handler_installed);
rl_callback_handler_install (prompt, gdb_rl_callback_handler);
- callback_handler_installed = 1;
+ callback_handler_installed = true;
}
/* See event-top.h, and above. */
struct ui *ui = current_ui;
if (ui->prompt_state == PROMPTED)
- internal_error (__FILE__, __LINE__, _("double prompt"));
+ internal_error (_("double prompt"));
else if (ui->prompt_state == PROMPT_BLOCKED)
{
/* This is to trick readline into not trying to display the
/* 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. */
- fprintf_unfiltered (gdb_stdout, "%s", actual_gdb_prompt.c_str ());
+ printf_unfiltered ("%s", actual_gdb_prompt.c_str ());
gdb_flush (gdb_stdout);
}
}
static std::string
top_level_prompt (void)
{
- char *prompt;
-
/* Give observers a chance of changing the prompt. E.g., the python
`gdb.prompt_hook' is installed as an observer. */
- gdb::observers::before_prompt.notify (get_prompt ());
+ gdb::observers::before_prompt.notify (get_prompt ().c_str ());
- prompt = get_prompt ();
+ const std::string &prompt = get_prompt ();
if (annotation_level >= 2)
{
beginning. */
const char suffix[] = "\n\032\032prompt\n";
- return std::string (prefix) + prompt + suffix;
+ return std::string (prefix) + prompt.c_str () + suffix;
}
return prompt;
struct ui *current_ui;
struct ui *ui_list;
-/* Get a pointer to the current UI's line buffer. This is used to
+/* Get a reference to the current UI's line buffer. This is used to
construct a whole line of input from partial input. */
-static struct buffer *
+static std::string &
get_command_line_buffer (void)
{
- return ¤t_ui->line_buffer;
+ return current_ui->line_buffer;
}
/* When there is an event ready on the stdin file descriptor, instead
instead of calling gdb_readline_no_editing_callback, give gdb a
chance to detect errors and do something. */
-void
+static void
stdin_event_handler (int error, gdb_client_data client_data)
{
struct ui *ui = (struct ui *) client_data;
/* Switch to the main UI, so diagnostics always go there. */
current_ui = main_ui;
- delete_file_handler (ui->input_fd);
+ ui->unregister_file_handler ();
if (main_ui == ui)
{
/* If stdin died, we may as well kill gdb. */
- printf_unfiltered (_("error detected on stdin\n"));
+ gdb_printf (gdb_stderr, _("error detected on stdin\n"));
quit_command ((char *) 0, 0);
}
else
/* See top.h. */
void
-ui_register_input_event_handler (struct ui *ui)
+ui::register_file_handler ()
{
- add_file_handler (ui->input_fd, stdin_event_handler, ui,
- string_printf ("ui-%d", ui->num), true);
+ if (input_fd != -1)
+ add_file_handler (input_fd, stdin_event_handler, this,
+ string_printf ("ui-%d", num), true);
}
/* See top.h. */
void
-ui_unregister_input_event_handler (struct ui *ui)
+ui::unregister_file_handler ()
{
- delete_file_handler (ui->input_fd);
+ if (input_fd != -1)
+ delete_file_handler (input_fd);
}
/* Re-enable stdin after the end of an execution command in
if (ui->prompt_state == PROMPT_BLOCKED)
{
target_terminal::ours ();
- ui_register_input_event_handler (ui);
+ ui->register_file_handler ();
ui->prompt_state = PROMPT_NEEDED;
}
}
struct ui *ui = current_ui;
ui->prompt_state = PROMPT_BLOCKED;
- delete_file_handler (ui->input_fd);
+ ui->unregister_file_handler ();
}
\f
}
}
-/* Append RL, an input line returned by readline or one of its
- emulations, to CMD_LINE_BUFFER. Returns the command line if we
- have a whole command line ready to be processed by the command
- interpreter or NULL if the command line isn't complete yet (input
- line ends in a backslash). */
+/* Append RL, an input line returned by readline or one of its emulations, to
+ CMD_LINE_BUFFER. Return true if we have a whole command line ready to be
+ processed by the command interpreter or false if the command line isn't
+ complete yet (input line ends in a backslash). */
-static char *
-command_line_append_input_line (struct buffer *cmd_line_buffer, const char *rl)
+static bool
+command_line_append_input_line (std::string &cmd_line_buffer, const char *rl)
{
- char *cmd;
- size_t len;
-
- len = strlen (rl);
+ size_t len = strlen (rl);
if (len > 0 && rl[len - 1] == '\\')
{
/* Don't copy the backslash and wait for more. */
- buffer_grow (cmd_line_buffer, rl, len - 1);
- cmd = NULL;
+ cmd_line_buffer.append (rl, len - 1);
+ return false;
}
else
{
/* Copy whole line including terminating null, and we're
done. */
- buffer_grow (cmd_line_buffer, rl, len + 1);
- cmd = cmd_line_buffer->buffer;
+ cmd_line_buffer.append (rl, len + 1);
+ return true;
}
-
- return cmd;
}
/* Handle a line of input coming from readline.
- If the read line ends with a continuation character (backslash),
- save the partial input in CMD_LINE_BUFFER (except the backslash),
- and return NULL. Otherwise, save the partial input and return a
- pointer to CMD_LINE_BUFFER's buffer (null terminated), indicating a
- whole command line is ready to be executed.
+ If the read line ends with a continuation character (backslash), return
+ nullptr. Otherwise, return a pointer to the command line, indicating a whole
+ command line is ready to be executed.
+
+ The returned pointer may or may not point to CMD_LINE_BUFFER's internal
+ buffer.
- Returns EOF on end of file.
+ Return EOF on end of file.
If REPEAT, handle command repetitions:
command instead of the empty input line.
*/
-char *
-handle_line_of_input (struct buffer *cmd_line_buffer,
+const char *
+handle_line_of_input (std::string &cmd_line_buffer,
const char *rl, int repeat,
const char *annotation_suffix)
{
struct ui *ui = current_ui;
int from_tty = ui->instream == ui->stdin_stream;
- char *p1;
- char *cmd;
if (rl == NULL)
return (char *) EOF;
- cmd = command_line_append_input_line (cmd_line_buffer, rl);
- if (cmd == NULL)
+ bool complete = command_line_append_input_line (cmd_line_buffer, rl);
+ if (!complete)
return NULL;
- /* We have a complete command line now. Prepare for the next
- command, but leave ownership of memory to the buffer . */
- cmd_line_buffer->used_size = 0;
-
if (from_tty && annotation_level > 1)
- {
- printf_unfiltered (("\n\032\032post-"));
- puts_unfiltered (annotation_suffix);
- printf_unfiltered (("\n"));
- }
+ printf_unfiltered (("\n\032\032post-%s\n"), annotation_suffix);
#define SERVER_COMMAND_PREFIX "server "
- server_command = startswith (cmd, SERVER_COMMAND_PREFIX);
+ server_command = startswith (cmd_line_buffer.c_str (), SERVER_COMMAND_PREFIX);
if (server_command)
{
/* 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);
+ return cmd_line_buffer.c_str () + strlen (SERVER_COMMAND_PREFIX);
}
/* Do history expansion if that is wished. */
- if (history_expansion_p && from_tty && input_interactive_p (current_ui))
+ if (history_expansion_p && from_tty && current_ui->input_interactive_p ())
{
char *cmd_expansion;
int expanded;
- expanded = history_expand (cmd, &cmd_expansion);
+ /* Note: here, we pass a pointer to the std::string's internal buffer as
+ a `char *`. At the time of writing, readline's history_expand does
+ not modify the passed-in string. Ideally, readline should be modified
+ to make that parameter `const char *`. */
+ expanded = history_expand (&cmd_line_buffer[0], &cmd_expansion);
gdb::unique_xmalloc_ptr<char> history_value (cmd_expansion);
if (expanded)
{
- size_t len;
-
/* Print the changes. */
printf_unfiltered ("%s\n", history_value.get ());
/* If there was an error, call this function again. */
if (expanded < 0)
- return cmd;
-
- /* history_expand returns an allocated string. Just replace
- our buffer with it. */
- len = strlen (history_value.get ());
- xfree (buffer_finish (cmd_line_buffer));
- cmd_line_buffer->buffer = history_value.get ();
- cmd_line_buffer->buffer_size = len + 1;
- cmd = history_value.release ();
+ return cmd_line_buffer.c_str ();
+
+ cmd_line_buffer = history_value.get ();
}
}
/* If we just got an empty line, and that is supposed to repeat the
previous command, return the previously saved command. */
- for (p1 = cmd; *p1 == ' ' || *p1 == '\t'; p1++)
+ const char *p1;
+ for (p1 = cmd_line_buffer.c_str (); *p1 == ' ' || *p1 == '\t'; p1++)
;
if (repeat && *p1 == '\0')
return get_saved_command_line ();
and then later fetch it from the value history and remove the
'#'. The kill ring is probably better, but some people are in
the habit of commenting things out. */
- if (*cmd != '\0' && from_tty && input_interactive_p (current_ui))
- gdb_add_history (cmd);
+ if (cmd_line_buffer[0] != '\0' && from_tty && current_ui->input_interactive_p ())
+ gdb_add_history (cmd_line_buffer.c_str ());
/* Save into global buffer if appropriate. */
if (repeat)
{
- save_command_line (cmd);
+ save_command_line (cmd_line_buffer.c_str ());
+
+ /* It is important that we return a pointer to the saved command line
+ here, for the `cmd_start == saved_command_line` check in
+ execute_command to work. */
return get_saved_command_line ();
}
- else
- return cmd;
+
+ return cmd_line_buffer.c_str ();
+}
+
+/* See event-top.h. */
+
+void
+gdb_rl_deprep_term_function (void)
+{
+#ifdef RL_STATE_EOF
+ gdb::optional<scoped_restore_tmpl<int>> restore_eof_found;
+
+ if (RL_ISSTATE (RL_STATE_EOF))
+ {
+ printf_unfiltered ("quit\n");
+ restore_eof_found.emplace (&rl_eof_found, 0);
+ }
+
+#endif /* RL_STATE_EOF */
+
+ rl_deprep_terminal ();
}
/* Handle a complete line of input. This is called by the callback
void
command_line_handler (gdb::unique_xmalloc_ptr<char> &&rl)
{
- struct buffer *line_buffer = get_command_line_buffer ();
+ std::string &line_buffer = get_command_line_buffer ();
struct ui *ui = current_ui;
- char *cmd;
- cmd = handle_line_of_input (line_buffer, rl.get (), 1, "prompt");
+ const char *cmd = handle_line_of_input (line_buffer, rl.get (), 1, "prompt");
if (cmd == (char *) EOF)
{
/* stdin closed. The connection with the terminal is gone.
This happens at the end of a testsuite run, after Expect has
hung up but GDB is still alive. In such a case, we just quit
- gdb killing the inferior program too. */
+ gdb killing the inferior program too. This also happens if the
+ user sends EOF, which is usually bound to ctrl+d. */
+
+#ifndef RL_STATE_EOF
+ /* When readline is using bracketed paste mode, then, when eof is
+ received, readline will emit the control sequence to leave
+ bracketed paste mode.
+
+ This control sequence ends with \r, which means that the "quit" we
+ are about to print will overwrite the prompt on this line.
+
+ The solution to this problem is to actually print the "quit"
+ message from gdb_rl_deprep_term_function (see above), however, we
+ can only do that if we can know, in that function, when eof was
+ received.
+
+ Unfortunately, with older versions of readline, it is not possible
+ in the gdb_rl_deprep_term_function to know if eof was received or
+ not, and, as GDB can be built against the system readline, which
+ could be older than the readline in GDB's repository, then we
+ can't be sure that we can work around this prompt corruption in
+ the gdb_rl_deprep_term_function function.
+
+ If we get here, RL_STATE_EOF is not defined. This indicates that
+ we are using an older readline, and couldn't print the quit
+ message in gdb_rl_deprep_term_function. So, what we do here is
+ check to see if bracketed paste mode is on or not. If it's on
+ then we print a \n and then the quit, this means the user will
+ see:
+
+ (gdb)
+ quit
+
+ Rather than the usual:
+
+ (gdb) quit
+
+ Which we will get with a newer readline, but this really is the
+ best we can do with older versions of readline. */
+ const char *value = rl_variable_value ("enable-bracketed-paste");
+ if (value != nullptr && strcmp (value, "on") == 0
+ && ((rl_readline_version >> 8) & 0xff) > 0x07)
+ printf_unfiltered ("\n");
printf_unfiltered ("quit\n");
+#endif
+
execute_command ("quit", 1);
}
else if (cmd == NULL)
{
ui->prompt_state = PROMPT_NEEDED;
+ /* Ensure the UI's line buffer is empty for the next command. */
+ SCOPE_EXIT { line_buffer.clear (); };
+
command_handler (cmd);
if (ui->prompt_state != PROMPTED)
int c;
char *result;
struct buffer line_buffer;
- static int done_once = 0;
struct ui *ui = current_ui;
buffer_init (&line_buffer);
- /* Unbuffer the input stream, so that, later on, the calls to fgetc
- fetch only one char at the time from the stream. The fgetc's will
- get up to the first newline, but there may be more chars in the
- stream after '\n'. If we buffer the input and fgetc drains the
- stream, getting stuff beyond the newline as well, a select, done
- afterwards will not trigger. */
- if (!done_once && !ISATTY (ui->instream))
- {
- setbuf (ui->instream, NULL);
- done_once = 1;
- }
+ FILE *stream = ui->instream != nullptr ? ui->instream : ui->stdin_stream;
+ gdb_assert (stream != nullptr);
/* We still need the while loop here, even though it would seem
obvious to invoke gdb_readline_no_editing_callback at every
{
/* Read from stdin if we are executing a user defined command.
This is the right thing for prompt_for_continue, at least. */
- c = fgetc (ui->instream != NULL ? ui->instream : ui->stdin_stream);
+ c = fgetc (stream);
if (c == EOF)
{
}
\f
+/* Attempt to unblock signal SIG, return true if the signal was unblocked,
+ otherwise, return false. */
+
+static bool
+unblock_signal (int sig)
+{
+#if HAVE_SIGPROCMASK
+ sigset_t sigset;
+ sigemptyset (&sigset);
+ sigaddset (&sigset, sig);
+ gdb_sigmask (SIG_UNBLOCK, &sigset, 0);
+ return true;
+#endif
+
+ return false;
+}
+
+/* Called to handle fatal signals. SIG is the signal number. */
+
+static void ATTRIBUTE_NORETURN
+handle_fatal_signal (int sig)
+{
+#ifdef GDB_PRINT_INTERNAL_BACKTRACE
+ const auto sig_write = [] (const char *msg) -> void
+ {
+ gdb_stderr->write_async_safe (msg, strlen (msg));
+ };
+
+ if (bt_on_fatal_signal)
+ {
+ sig_write ("\n\n");
+ sig_write (_("Fatal signal: "));
+ sig_write (strsignal (sig));
+ sig_write ("\n");
+
+ gdb_internal_backtrace ();
+
+ sig_write (_("A fatal error internal to GDB has been detected, "
+ "further\ndebugging is not possible. GDB will now "
+ "terminate.\n\n"));
+ sig_write (_("This is a bug, please report it."));
+ if (REPORT_BUGS_TO[0] != '\0')
+ {
+ sig_write (_(" For instructions, see:\n"));
+ sig_write (REPORT_BUGS_TO);
+ sig_write (".");
+ }
+ sig_write ("\n\n");
+
+ gdb_stderr->flush ();
+ }
+#endif
+
+ /* If possible arrange for SIG to have its default behaviour (which
+ should be to terminate the current process), unblock SIG, and reraise
+ the signal. This ensures GDB terminates with the expected signal. */
+ if (signal (sig, SIG_DFL) != SIG_ERR
+ && unblock_signal (sig))
+ raise (sig);
+
+ /* The above failed, so try to use SIGABRT to terminate GDB. */
+#ifdef SIGABRT
+ signal (SIGABRT, SIG_DFL);
+#endif
+ abort (); /* ARI: abort */
+}
+
/* The SIGSEGV handler for this thread, or NULL if there is none. GDB
always installs a global SIGSEGV handler, and then lets threads
indicate their interest in handling the signal by setting this
install_handle_sigsegv ();
if (thread_local_segv_handler == nullptr)
- abort (); /* ARI: abort */
+ handle_fatal_signal (sig);
thread_local_segv_handler (sig);
}
handler. */
static struct serial_event *quit_serial_event;
-/* Initialization of signal handlers and tokens. There is a function
- handle_sig* for each of the signals GDB cares about. Specifically:
- SIGINT, SIGFPE, SIGQUIT, SIGTSTP, SIGHUP, SIGWINCH. These
- functions are the actual signal handlers associated to the signals
- via calls to signal(). The only job for these functions is to
- enqueue the appropriate event/procedure with the event loop. Such
- procedures are the old signal handlers. The event loop will take
- care of invoking the queued procedures to perform the usual tasks
- associated with the reception of the signal. */
-/* NOTE: 1999-04-30 This is the asynchronous version of init_signals.
- init_signals will become obsolete as we move to have to event loop
- as the default for gdb. */
+/* Initialization of signal handlers and tokens. There are a number of
+ different strategies for handling different signals here.
+
+ For SIGINT, SIGTERM, SIGQUIT, SIGHUP, SIGTSTP, there is a function
+ handle_sig* for each of these signals. These functions are the actual
+ signal handlers associated to the signals via calls to signal(). The
+ only job for these functions is to enqueue the appropriate
+ event/procedure with the event loop. The event loop will take care of
+ invoking the queued procedures to perform the usual tasks associated
+ with the reception of the signal.
+
+ For SIGSEGV the handle_sig* function does all the work for handling this
+ signal.
+
+ For SIGFPE, SIGBUS, and SIGABRT, these signals will all cause GDB to
+ terminate immediately. */
void
-async_init_signals (void)
+gdb_init_signals (void)
{
initialize_async_signal_handlers ();
quit_serial_event = make_serial_event ();
- signal (SIGINT, handle_sigint);
sigint_token =
create_async_signal_handler (async_request_quit, NULL, "sigint");
- signal (SIGTERM, handle_sigterm);
+ install_sigint_handler (handle_sigint);
+
async_sigterm_token
= 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. */
-#ifdef SIGTRAP
- signal (SIGTRAP, SIG_DFL);
-#endif
+ signal (SIGTERM, handle_sigterm);
#ifdef SIGQUIT
- /* If we initialize SIGQUIT to SIG_IGN, then the SIG_IGN will get
- passed to the inferior, which we don't want. It would be
- possible to do a "signal (SIGQUIT, SIG_DFL)" after we fork, but
- on BSD4.3 systems using vfork, that can affect the
- GDB process as well as the inferior (the signal handling tables
- might be in memory, shared between the two). Since we establish
- a handler for SIGQUIT, when we call exec it will set the signal
- to SIG_DFL for us. */
- signal (SIGQUIT, handle_sigquit);
sigquit_token =
create_async_signal_handler (async_do_nothing, NULL, "sigquit");
+ signal (SIGQUIT, handle_sigquit);
#endif
+
#ifdef SIGHUP
if (signal (SIGHUP, handle_sighup) != SIG_IGN)
sighup_token =
sighup_token =
create_async_signal_handler (async_do_nothing, NULL, "sighup");
#endif
- signal (SIGFPE, handle_sigfpe);
- sigfpe_token =
- create_async_signal_handler (async_float_handler, NULL, "sigfpe");
#ifdef SIGTSTP
sigtstp_token =
create_async_signal_handler (async_sigtstp_handler, NULL, "sigtstp");
#endif
+#ifdef SIGFPE
+ signal (SIGFPE, handle_fatal_signal);
+#endif
+
+#ifdef SIGBUS
+ signal (SIGBUS, handle_fatal_signal);
+#endif
+
+#ifdef SIGABRT
+ signal (SIGABRT, handle_fatal_signal);
+#endif
+
install_handle_sigsegv ();
}
catch (const gdb_exception &exception)
{
- fputs_filtered ("Could not kill the program being debugged",
- gdb_stderr);
+ gdb_puts ("Could not kill the program being debugged",
+ gdb_stderr);
exception_print (gdb_stderr, exception);
}
for (inferior *inf : all_inferiors ())
{
- switch_to_inferior_no_thread (inf);
try
{
- pop_all_targets ();
+ inf->pop_all_targets ();
}
catch (const gdb_exception &exception)
{
static void
async_sigtstp_handler (gdb_client_data arg)
{
- char *prompt = get_prompt ();
+ const std::string &prompt = get_prompt ();
signal (SIGTSTP, SIG_DFL);
-#if HAVE_SIGPROCMASK
- {
- sigset_t zero;
-
- sigemptyset (&zero);
- gdb_sigmask (SIG_SETMASK, &zero, 0);
- }
-#elif HAVE_SIGSETMASK
- sigsetmask (0);
-#endif
+ unblock_signal (SIGTSTP);
raise (SIGTSTP);
signal (SIGTSTP, handle_sigtstp);
- printf_unfiltered ("%s", prompt);
+ printf_unfiltered ("%s", prompt.c_str ());
gdb_flush (gdb_stdout);
/* Forget about any previous command -- null line now will do
}
#endif /* SIGTSTP */
-/* Tell the event loop what to do if SIGFPE is received.
- See event-signal.c. */
-static void
-handle_sigfpe (int sig)
-{
- mark_async_signal_handler (sigfpe_token);
- signal (sig, handle_sigfpe);
-}
-
-/* Event loop will call this function to process a SIGFPE. */
-static void
-async_float_handler (gdb_client_data arg)
-{
- /* This message is based on ANSI C, section 4.7. Note that integer
- divide by zero causes this, so "float" is a misnomer. */
- error (_("Erroneous arithmetic operation."));
-}
\f
/* Set things up for readline to be invoked via the alternate
{
struct ui *ui = current_ui;
- /* This function is a noop for the sync case. The assumption is
- that the sync setup is ALL done in gdb_init, and we would only
- mess it up here. The sync stuff should really go away over
- time. */
- if (!batch_silent)
- gdb_stdout = new stdio_file (ui->outstream);
- gdb_stderr = new stderr_file (ui->errstream);
- gdb_stdlog = gdb_stderr; /* for moment */
- gdb_stdtarg = gdb_stderr; /* for moment */
- gdb_stdtargerr = gdb_stderr; /* for moment */
-
/* If the input stream is connected to a terminal, turn on editing.
However, that is only allowed on the main UI, as we can only have
- one instance of readline. */
- if (ISATTY (ui->instream) && editing && ui == main_ui)
+ one instance of readline. Also, INSTREAM might be nullptr when
+ executing a user-defined command. */
+ if (ui->instream != nullptr && ISATTY (ui->instream)
+ && editing && ui == main_ui)
{
/* Tell gdb that we will be using the readline library. This
could be overwritten by a command in .gdbinit like 'set
Another source is going to be the target program (inferior), but
that must be registered only when it actually exists (I.e. after
we say 'run' or after we connect to a remote target. */
- ui_register_input_event_handler (ui);
+ ui->register_file_handler ();
}
/* Disable command input through the standard CLI channels. Used in
{
struct ui *ui = current_ui;
- /* FIXME - It is too heavyweight to delete and remake these every
- time you run an interpreter that needs readline. It is probably
- better to have the interpreters cache these, which in turn means
- that this needs to be moved into interpreter specific code. */
-
-#if 0
- ui_file_delete (gdb_stdout);
- ui_file_delete (gdb_stderr);
- gdb_stdlog = NULL;
- gdb_stdtarg = NULL;
- gdb_stdtargerr = NULL;
-#endif
-
if (ui->command_editing)
gdb_rl_callback_handler_remove ();
- delete_file_handler (ui->input_fd);
+ ui->unregister_file_handler ();
}
scoped_segv_handler_restore::scoped_segv_handler_restore (segv_handler_t new_handler)
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);
+ gdb_printf (file, _("Event loop debugging is %s.\n"), value);
}
void _initialize_event_top ();
set_debug_event_loop_command,
show_debug_event_loop_command,
&setdebuglist, &showdebuglist);
+
+ add_setshow_boolean_cmd ("backtrace-on-fatal-signal", class_maintenance,
+ &bt_on_fatal_signal, _("\
+Set whether to produce a backtrace if GDB receives a fatal signal."), _("\
+Show whether GDB will produce a backtrace if it receives a fatal signal."), _("\
+Use \"on\" to enable, \"off\" to disable.\n\
+If enabled, GDB will produce a minimal backtrace if it encounters a fatal\n\
+signal from within GDB itself. This is a mechanism to help diagnose\n\
+crashes within GDB, not a mechanism for debugging inferiors."),
+ gdb_internal_backtrace_set_cmd,
+ show_bt_on_fatal_signal,
+ &maintenance_set_cmdlist,
+ &maintenance_show_cmdlist);
}
projects / thirdparty / binutils-gdb.git / blobdiff