/* Memory-access and commands for "inferior" process, for GDB.
- Copyright (C) 1986-2020 Free Software Foundation, Inc.
+ Copyright (C) 1986-2022 Free Software Foundation, Inc.
This file is part of GDB.
#include "inline-frame.h"
#include "tracepoint.h"
#include "inf-loop.h"
-#include "continuations.h"
#include "linespec.h"
#include "thread-fsm.h"
#include "top.h"
static void step_1 (int, int, const char *);
#define ERROR_NO_INFERIOR \
- if (!target_has_execution) error (_("The program is not being run."));
+ if (!target_has_execution ()) error (_("The program is not being run."));
/* Scratch area where string containing arguments to give to the
program will be stored by 'set args'. As soon as anything is
Arguments are separated by spaces. Empty string (pointer to '\0')
means no args. */
-static char *inferior_args_scratch;
+static std::string inferior_args_scratch;
/* Scratch area where the new cwd will be stored by 'set cwd'. */
-static char *inferior_cwd_scratch;
+static std::string inferior_cwd_scratch;
/* Scratch area where 'set inferior-tty' will store user-provided value.
We'll immediate copy it into per-inferior storage. */
-static char *inferior_io_terminal_scratch;
+static std::string inferior_io_terminal_scratch;
/* Pid of our debugged inferior, or 0 if no inferior now.
Since various parts of infrun.c test this to see whether there is a program
int stopped_by_random_signal;
\f
-/* Accessor routines. */
-
-/* Set the io terminal for the current inferior. Ownership of
- TERMINAL_NAME is not transferred. */
-
-void
-set_inferior_io_terminal (const char *terminal_name)
-{
- xfree (current_inferior ()->terminal);
-
- if (terminal_name != NULL && *terminal_name != '\0')
- current_inferior ()->terminal = xstrdup (terminal_name);
- else
- current_inferior ()->terminal = NULL;
-}
-
-const char *
-get_inferior_io_terminal (void)
-{
- return current_inferior ()->terminal;
-}
static void
set_inferior_tty_command (const char *args, int from_tty,
{
/* CLI has assigned the user-provided value to inferior_io_terminal_scratch.
Now route it to current inferior. */
- set_inferior_io_terminal (inferior_io_terminal_scratch);
+ current_inferior ()->set_tty (inferior_io_terminal_scratch);
}
static void
{
/* Note that we ignore the passed-in value in favor of computing it
directly. */
- const char *inferior_io_terminal = get_inferior_io_terminal ();
-
- if (inferior_io_terminal == NULL)
- inferior_io_terminal = "";
- fprintf_filtered (gdb_stdout,
- _("Terminal for future runs of program being debugged "
- "is \"%s\".\n"), inferior_io_terminal);
-}
-
-const char *
-get_inferior_args (void)
-{
- if (current_inferior ()->argc != 0)
- {
- gdb::array_view<char * const> args (current_inferior ()->argv,
- current_inferior ()->argc);
- std::string n = construct_inferior_arguments (args);
- set_inferior_args (n.c_str ());
- }
-
- if (current_inferior ()->args == NULL)
- current_inferior ()->args = xstrdup ("");
-
- return current_inferior ()->args;
-}
+ const std::string &inferior_tty = current_inferior ()->tty ();
-/* Set the arguments for the current inferior. Ownership of
- NEWARGS is not transferred. */
-
-void
-set_inferior_args (const char *newargs)
-{
- xfree (current_inferior ()->args);
- current_inferior ()->args = newargs ? xstrdup (newargs) : NULL;
- current_inferior ()->argc = 0;
- current_inferior ()->argv = 0;
+ gdb_printf (file,
+ _("Terminal for future runs of program being debugged "
+ "is \"%s\".\n"), inferior_tty.c_str ());
}
void
set_inferior_args_vector (int argc, char **argv)
{
- current_inferior ()->argc = argc;
- current_inferior ()->argv = argv;
+ gdb::array_view<char * const> args (argv, argc);
+ std::string n = construct_inferior_arguments (args);
+ current_inferior ()->set_args (std::move (n));
}
/* Notice when `set args' is run. */
{
/* CLI has assigned the user-provided value to inferior_args_scratch.
Now route it to current inferior. */
- set_inferior_args (inferior_args_scratch);
+ current_inferior ()->set_args (inferior_args_scratch);
}
/* Notice when `show args' is run. */
{
/* Note that we ignore the passed-in value in favor of computing it
directly. */
- deprecated_show_value_hack (file, from_tty, c, get_inferior_args ());
-}
-
-/* See gdbsupport/common-inferior.h. */
-
-void
-set_inferior_cwd (const char *cwd)
-{
- struct inferior *inf = current_inferior ();
-
- gdb_assert (inf != NULL);
-
- if (cwd == NULL)
- inf->cwd.reset ();
- else
- inf->cwd.reset (xstrdup (cwd));
+ deprecated_show_value_hack (file, from_tty, c,
+ current_inferior ()->args ().c_str ());
}
/* See gdbsupport/common-inferior.h. */
-const char *
+const std::string &
get_inferior_cwd ()
{
- return current_inferior ()->cwd.get ();
+ return current_inferior ()->cwd ();
}
/* Handle the 'set cwd' command. */
static void
set_cwd_command (const char *args, int from_tty, struct cmd_list_element *c)
{
- if (*inferior_cwd_scratch == '\0')
- set_inferior_cwd (NULL);
- else
- set_inferior_cwd (inferior_cwd_scratch);
+ current_inferior ()->set_cwd (inferior_cwd_scratch);
}
/* Handle the 'show cwd' command. */
show_cwd_command (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
{
- const char *cwd = get_inferior_cwd ();
+ const std::string &cwd = current_inferior ()->cwd ();
- if (cwd == NULL)
- fprintf_filtered (gdb_stdout,
- _("\
+ if (cwd.empty ())
+ gdb_printf (file,
+ _("\
You have not set the inferior's current working directory.\n\
The inferior will inherit GDB's cwd if native debugging, or the remote\n\
server's cwd if remote debugging.\n"));
else
- fprintf_filtered (gdb_stdout,
- _("Current working directory that will be used "
- "when starting the inferior is \"%s\".\n"), cwd);
+ gdb_printf (file,
+ _("Current working directory that will be used "
+ "when starting the inferior is \"%s\".\n"),
+ cwd.c_str ());
}
should be stopped. */
void
-post_create_inferior (struct target_ops *target, int from_tty)
+post_create_inferior (int from_tty)
{
/* Be sure we own the terminal in case write operations are performed. */
missing registers info), ignore it. */
thread_info *thr = inferior_thread ();
- thr->suspend.stop_pc = 0;
+ thr->clear_stop_pc ();
try
{
regcache *rc = get_thread_regcache (thr);
- thr->suspend.stop_pc = regcache_read_pc (rc);
+ thr->set_stop_pc (regcache_read_pc (rc));
}
catch (const gdb_exception_error &ex)
{
throw;
}
- if (exec_bfd)
+ if (current_program_space->exec_bfd ())
{
const unsigned solib_add_generation
= current_program_space->solib_add_generation;
+ scoped_restore restore_in_initial_library_scan
+ = make_scoped_restore (¤t_inferior ()->in_initial_library_scan,
+ true);
+
/* Create the hooks to handle shared library load and unload
events. */
solib_create_inferior_hook (from_tty);
if the now pushed target supports hardware watchpoints. */
breakpoint_re_set ();
- gdb::observers::inferior_created.notify (target, from_tty);
+ gdb::observers::inferior_created.notify (current_inferior ());
}
/* Kill the inferior if already running. This function is designed
static void
kill_if_already_running (int from_tty)
{
- if (inferior_ptid != null_ptid && target_has_execution)
+ if (inferior_ptid != null_ptid && target_has_execution ())
{
/* Bail out before killing the program if we will not be able to
restart it. */
{
/* If we get a request for running in the bg but the target
doesn't support it, error out. */
- if (background && !target->can_async_p ())
+ if (background && !target_can_async_p (target))
error (_("Asynchronous execution not supported on this target."));
if (!background)
dont_repeat ();
+ scoped_disable_commit_resumed disable_commit_resumed ("running");
+
kill_if_already_running (from_tty);
init_wait_for_inferior ();
to check again here. Since reopen_exec_file doesn't do anything
if the timestamp hasn't changed, I don't see the harm. */
reopen_exec_file ();
- reread_symbols ();
+ reread_symbols (from_tty);
gdb::unique_xmalloc_ptr<char> stripped = strip_bg_char (args, &async_exec);
args = stripped.get ();
/* If there were other args, beside '&', process them. */
if (args != NULL)
- set_inferior_args (args);
+ current_inferior ()->set_args (args);
if (from_tty)
{
uiout->field_string (NULL, "Starting program");
uiout->text (": ");
if (exec_file)
- uiout->field_string ("execfile", exec_file);
+ uiout->field_string ("execfile", exec_file,
+ file_name_style.style ());
uiout->spaces (1);
- /* We call get_inferior_args() because we might need to compute
- the value now. */
- uiout->field_string ("infargs", get_inferior_args ());
+ uiout->field_string ("infargs", current_inferior ()->args ());
uiout->text ("\n");
uiout->flush ();
}
- /* We call get_inferior_args() because we might need to compute
- the value now. */
run_target->create_inferior (exec_file,
- std::string (get_inferior_args ()),
+ current_inferior ()->args (),
current_inferior ()->environment.envp (),
from_tty);
/* to_create_inferior should push the target, so after this point we
/* Pass zero for FROM_TTY, because at this point the "run" command
has done its thing; now we are setting up the running program. */
- post_create_inferior (current_top_target (), 0);
+ post_create_inferior (0);
/* Queue a pending event so that the program stops immediately. */
if (run_how == RUN_STOP_AT_FIRST_INSN)
{
thread_info *thr = inferior_thread ();
- thr->suspend.waitstatus_pending_p = 1;
- thr->suspend.waitstatus.kind = TARGET_WAITKIND_STOPPED;
- thr->suspend.waitstatus.value.sig = GDB_SIGNAL_0;
+ target_waitstatus ws;
+ ws.set_stopped (GDB_SIGNAL_0);
+ thr->set_pending_waitstatus (ws);
}
/* Start the target running. Do not use -1 continuation as it would skip
/* Since there was no error, there's no need to finish the thread
states here. */
finish_state.release ();
+
+ disable_commit_resumed.reset_and_commit ();
}
static void
/* Backup current thread and selected frame and restore on scope
exit. */
scoped_restore_current_thread restore_thread;
+ scoped_disable_commit_resumed disable_commit_resumed
+ ("continue all threads in non-stop");
iterate_over_threads (proceed_thread_callback, NULL);
*/
target_terminal::inferior ();
}
+
+ disable_commit_resumed.reset_and_commit ();
}
else
{
stopped at. */
if (args != NULL)
{
- bpstat bs = NULL;
+ bpstat *bs = nullptr;
int num, stat;
int stopped = 0;
struct thread_info *tp;
/* set_ignore_count prints a message ending with a period.
So print two spaces before "Continuing.". */
if (from_tty)
- printf_filtered (" ");
+ gdb_printf (" ");
stopped = 1;
}
if (!stopped && from_tty)
{
- printf_filtered
+ gdb_printf
("Not stopped at any breakpoint; argument ignored.\n");
}
}
ensure_not_running ();
}
- prepare_execution_command (current_top_target (), async_exec);
+ prepare_execution_command (current_inferior ()->top_target (), async_exec);
if (from_tty)
- printf_filtered (_("Continuing.\n"));
+ gdb_printf (_("Continuing.\n"));
continue_1 (all_threads_p);
}
= strip_bg_char (count_string, &async_exec);
count_string = stripped.get ();
- prepare_execution_command (current_top_target (), async_exec);
+ prepare_execution_command (current_inferior ()->top_target (), async_exec);
count = count_string ? parse_and_eval_long (count_string) : 1;
steps. */
thr = inferior_thread ();
step_sm = new step_command_fsm (command_interp ());
- thr->thread_fsm = step_sm;
+ thr->set_thread_fsm (std::unique_ptr<thread_fsm> (step_sm));
step_command_fsm_prepare (step_sm, skip_subroutines,
single_inst, count, thr);
/* Stepped into an inline frame. Pretend that we've
stopped. */
- thr->thread_fsm->clean_up (thr);
+ thr->thread_fsm ()->clean_up (thr);
proceeded = normal_stop ();
if (!proceeded)
- inferior_event_handler (INF_EXEC_COMPLETE, NULL);
+ inferior_event_handler (INF_EXEC_COMPLETE);
all_uis_check_sync_execution_done ();
}
}
&tp->control.step_range_start,
&tp->control.step_range_end);
+ /* There's a problem in gcc (PR gcc/98780) that causes missing line
+ table entries, which results in a too large stepping range.
+ Use inlined_subroutine info to make the range more narrow. */
+ if (inline_skipped_frames (tp) > 0)
+ {
+ symbol *sym = inline_skipped_symbol (tp);
+ if (sym->aclass () == LOC_BLOCK)
+ {
+ const block *block = SYMBOL_BLOCK_VALUE (sym);
+ if (BLOCK_END (block) < tp->control.step_range_end)
+ tp->control.step_range_end = BLOCK_END (block);
+ }
+ }
+
tp->control.may_range_step = 1;
/* If we have no line info, switch to stepi mode. */
error (_("Cannot find bounds of current function"));
target_terminal::ours_for_output ();
- printf_filtered (_("Single stepping until exit from function %s,"
- "\nwhich has no line number information.\n"),
- name);
+ gdb_printf (_("Single stepping until exit from function %s,"
+ "\nwhich has no line number information.\n"),
+ name);
}
}
else
gdb::unique_xmalloc_ptr<char> stripped = strip_bg_char (arg, &async_exec);
arg = stripped.get ();
- prepare_execution_command (current_top_target (), async_exec);
+ prepare_execution_command (current_inferior ()->top_target (), async_exec);
if (!arg)
error_no_arg (_("starting address"));
struct obj_section *section;
fixup_symbol_section (sfn, 0);
- section = SYMBOL_OBJ_SECTION (symbol_objfile (sfn), sfn);
+ section = sfn->obj_section (symbol_objfile (sfn));
if (section_is_overlay (section)
&& !section_is_mapped (section))
{
if (from_tty)
{
- printf_filtered (_("Continuing at "));
- fputs_filtered (paddress (gdbarch, addr), gdb_stdout);
- printf_filtered (".\n");
+ gdb_printf (_("Continuing at "));
+ gdb_puts (paddress (gdbarch, addr));
+ gdb_printf (".\n");
}
clear_proceed_status (0);
= strip_bg_char (signum_exp, &async_exec);
signum_exp = stripped.get ();
- prepare_execution_command (current_top_target (), async_exec);
+ prepare_execution_command (current_inferior ()->top_target (), async_exec);
if (!signum_exp)
error_no_arg (_("signal number"));
if (tp == current)
continue;
- if (tp->suspend.stop_signal != GDB_SIGNAL_0
- && signal_pass_state (tp->suspend.stop_signal))
+ if (tp->stop_signal () != GDB_SIGNAL_0
+ && signal_pass_state (tp->stop_signal ()))
{
if (!must_confirm)
- printf_unfiltered (_("Note:\n"));
- printf_unfiltered (_(" Thread %s previously stopped with signal %s, %s.\n"),
- print_thread_id (tp),
- gdb_signal_to_name (tp->suspend.stop_signal),
- gdb_signal_to_string (tp->suspend.stop_signal));
+ gdb_printf (_("Note:\n"));
+ gdb_printf (_(" Thread %s previously stopped with signal %s, %s.\n"),
+ print_thread_id (tp),
+ gdb_signal_to_name (tp->stop_signal ()),
+ gdb_signal_to_string (tp->stop_signal ()));
must_confirm = 1;
}
}
if (from_tty)
{
if (oursig == GDB_SIGNAL_0)
- printf_filtered (_("Continuing with no signal.\n"));
+ gdb_printf (_("Continuing with no signal.\n"));
else
- printf_filtered (_("Continuing with signal %s.\n"),
- gdb_signal_to_name (oursig));
+ gdb_printf (_("Continuing with signal %s.\n"),
+ gdb_signal_to_name (oursig));
}
clear_proceed_status (0);
error (_("Signal handling set to not pass this signal to the program."));
tp = inferior_thread ();
- tp->suspend.stop_signal = oursig;
+ tp->set_stop_signal (oursig);
}
/* Data for the FSM that manages the until (with no argument)
tp->control.step_range_start = BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (func));
tp->control.step_range_end = sal.end;
+
+ /* By setting the step_range_end based on the current pc, we are
+ assuming that the last line table entry for any given source line
+ will have is_stmt set to true. This is not necessarily the case,
+ there may be additional entries for the same source line with
+ is_stmt set false. Consider the following code:
+
+ for (int i = 0; i < 10; i++)
+ loop_body ();
+
+ Clang-13, will generate multiple line table entries at the end of
+ the loop all associated with the 'for' line. The first of these
+ entries is marked is_stmt true, but the other entries are is_stmt
+ false.
+
+ If we only use the values in SAL, then our stepping range may not
+ extend to the end of the loop. The until command will reach the
+ end of the range, find a non is_stmt instruction, and step to the
+ next is_stmt instruction. This stopping point, however, will be
+ inside the loop, which is not what we wanted.
+
+ Instead, we now check any subsequent line table entries to see if
+ they are for the same line. If they are, and they are marked
+ is_stmt false, then we extend the end of our stepping range.
+
+ When we finish this process the end of the stepping range will
+ point either to a line with a different line number, or, will
+ point at an address for the same line number that is marked as a
+ statement. */
+
+ struct symtab_and_line final_sal
+ = find_pc_line (tp->control.step_range_end, 0);
+
+ while (final_sal.line == sal.line && final_sal.symtab == sal.symtab
+ && !final_sal.is_stmt)
+ {
+ tp->control.step_range_end = final_sal.end;
+ final_sal = find_pc_line (final_sal.end, 0);
+ }
}
tp->control.may_range_step = 1;
delete_longjmp_breakpoint_cleanup lj_deleter (thread);
sm = new until_next_fsm (command_interp (), tp->global_num);
- tp->thread_fsm = sm;
+ tp->set_thread_fsm (std::unique_ptr<thread_fsm> (sm));
lj_deleter.release ();
proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT);
gdb::unique_xmalloc_ptr<char> stripped = strip_bg_char (arg, &async_exec);
arg = stripped.get ();
- prepare_execution_command (current_top_target (), async_exec);
+ prepare_execution_command (current_inferior ()->top_target (), async_exec);
if (arg)
until_break_command (arg, from_tty, 0);
gdb::unique_xmalloc_ptr<char> stripped = strip_bg_char (arg, &async_exec);
arg = stripped.get ();
- prepare_execution_command (current_top_target (), async_exec);
+ prepare_execution_command (current_inferior ()->top_target (), async_exec);
until_break_command (arg, from_tty, 1);
}
\f
-/* Return the value of the result of a function at the end of a 'finish'
- command/BP. DTOR_DATA (if not NULL) can represent inferior registers
- right after an inferior call has finished. */
+/* See inferior.h. */
struct value *
-get_return_value (struct value *function, struct type *value_type)
+get_return_value (struct symbol *func_symbol, struct value *function)
{
regcache *stop_regs = get_current_regcache ();
struct gdbarch *gdbarch = stop_regs->arch ();
struct value *value;
- value_type = check_typedef (value_type);
+ struct type *value_type
+ = check_typedef (TYPE_TARGET_TYPE (func_symbol->type ()));
gdb_assert (value_type->code () != TYPE_CODE_VOID);
+ if (is_nocall_function (check_typedef (::value_type (function))))
+ {
+ warning (_("Function '%s' does not follow the target calling "
+ "convention, cannot determine its returned value."),
+ func_symbol->print_name ());
+
+ return nullptr;
+ }
+
/* FIXME: 2003-09-27: When returning from a nested inferior function
call, it's possible (with no help from the architecture vector)
to locate and return/print a "struct return" value. This is just
calls are made async, this will likely be made the norm. */
switch (gdbarch_return_value (gdbarch, function, value_type,
- NULL, NULL, NULL))
+ NULL, NULL, NULL))
{
case RETURN_VALUE_REGISTER_CONVENTION:
case RETURN_VALUE_ABI_RETURNS_ADDRESS:
case RETURN_VALUE_ABI_PRESERVES_ADDRESS:
value = allocate_value (value_type);
gdbarch_return_value (gdbarch, function, value_type, stop_regs,
- value_contents_raw (value), NULL);
+ value_contents_raw (value).data (), NULL);
break;
case RETURN_VALUE_STRUCT_CONVENTION:
value = NULL;
{
std::string type_name = type_to_string (rv->type);
uiout->text ("Value returned has type: ");
- uiout->field_string ("return-type", type_name.c_str ());
+ uiout->field_string ("return-type", type_name);
uiout->text (".");
uiout->text (" Cannot determine contents\n");
}
/* We're done. */
set_finished ();
- rv->type = TYPE_TARGET_TYPE (SYMBOL_TYPE (function));
+ rv->type = TYPE_TARGET_TYPE (function->type ());
if (rv->type == NULL)
internal_error (__FILE__, __LINE__,
_("finish_command: function has no target type"));
struct value *func;
func = read_var_value (function, NULL, get_current_frame ());
- rv->value = get_return_value (func, rv->type);
+ rv->value = get_return_value (function, func);
if (rv->value != NULL)
rv->value_history_index = record_latest_value (rv->value);
}
gdb::unique_xmalloc_ptr<char> stripped = strip_bg_char (arg, &async_exec);
arg = stripped.get ();
- prepare_execution_command (current_top_target (), async_exec);
+ prepare_execution_command (current_inferior ()->top_target (), async_exec);
if (arg)
error (_("The \"finish\" command does not take any arguments."));
sm = new finish_command_fsm (command_interp ());
- tp->thread_fsm = sm;
+ tp->set_thread_fsm (std::unique_ptr<thread_fsm> (sm));
/* Finishing from an inline frame is completely different. We don't
try to show the "return value" - no way to locate it. */
source. */
if (from_tty)
{
- printf_filtered (_("Run till exit from "));
+ gdb_printf (_("Run till exit from "));
print_stack_frame (get_selected_frame (NULL), 1, LOCATION, 0);
}
if (from_tty)
{
if (execution_direction == EXEC_REVERSE)
- printf_filtered (_("Run back to call of "));
+ gdb_printf (_("Run back to call of "));
else
{
- if (sm->function != NULL && TYPE_NO_RETURN (sm->function->type)
+ if (sm->function != NULL && TYPE_NO_RETURN (sm->function->type ())
&& !query (_("warning: Function %s does not return normally.\n"
"Try to finish anyway? "),
sm->function->print_name ()))
error (_("Not confirmed."));
- printf_filtered (_("Run till exit from "));
+ gdb_printf (_("Run till exit from "));
}
print_stack_frame (get_selected_frame (NULL), 1, LOCATION, 0);
static void
info_program_command (const char *args, int from_tty)
{
- bpstat bs;
+ bpstat *bs;
int num, stat;
ptid_t ptid;
process_stratum_target *proc_target;
- if (!target_has_execution)
+ if (!target_has_execution ())
{
- printf_filtered (_("The program being debugged is not being run.\n"));
+ gdb_printf (_("The program being debugged is not being run.\n"));
return;
}
stat = bpstat_num (&bs, &num);
target_files_info ();
- printf_filtered (_("Program stopped at %s.\n"),
- paddress (target_gdbarch (), tp->suspend.stop_pc));
+ gdb_printf (_("Program stopped at %s.\n"),
+ paddress (target_gdbarch (), tp->stop_pc ()));
if (tp->control.stop_step)
- printf_filtered (_("It stopped after being stepped.\n"));
+ gdb_printf (_("It stopped after being stepped.\n"));
else if (stat != 0)
{
/* There may be several breakpoints in the same place, so this
- isn't as strange as it seems. */
+ isn't as strange as it seems. */
while (stat != 0)
{
if (stat < 0)
{
- printf_filtered (_("It stopped at a breakpoint "
- "that has since been deleted.\n"));
+ gdb_printf (_("It stopped at a breakpoint "
+ "that has since been deleted.\n"));
}
else
- printf_filtered (_("It stopped at breakpoint %d.\n"), num);
+ gdb_printf (_("It stopped at breakpoint %d.\n"), num);
stat = bpstat_num (&bs, &num);
}
}
- else if (tp->suspend.stop_signal != GDB_SIGNAL_0)
+ else if (tp->stop_signal () != GDB_SIGNAL_0)
{
- printf_filtered (_("It stopped with signal %s, %s.\n"),
- gdb_signal_to_name (tp->suspend.stop_signal),
- gdb_signal_to_string (tp->suspend.stop_signal));
+ gdb_printf (_("It stopped with signal %s, %s.\n"),
+ gdb_signal_to_name (tp->stop_signal ()),
+ gdb_signal_to_string (tp->stop_signal ()));
}
if (from_tty)
{
- printf_filtered (_("Type \"info stack\" or \"info "
- "registers\" for more information.\n"));
+ gdb_printf (_("Type \"info stack\" or \"info "
+ "registers\" for more information.\n"));
}
}
\f
if (val)
{
- puts_filtered (var);
- puts_filtered (" = ");
- puts_filtered (val);
- puts_filtered ("\n");
+ gdb_puts (var);
+ gdb_puts (" = ");
+ gdb_puts (val);
+ gdb_puts ("\n");
}
else
{
- puts_filtered ("Environment variable \"");
- puts_filtered (var);
- puts_filtered ("\" not defined.\n");
+ gdb_puts ("Environment variable \"");
+ gdb_puts (var);
+ gdb_puts ("\" not defined.\n");
}
}
else
for (int idx = 0; envp[idx] != NULL; ++idx)
{
- puts_filtered (envp[idx]);
- puts_filtered ("\n");
+ gdb_puts (envp[idx]);
+ gdb_puts ("\n");
}
}
}
if (p != 0 && val != 0)
{
/* We have both a space and an equals. If the space is before the
- equals, walk forward over the spaces til we see a nonspace
- (possibly the equals). */
+ equals, walk forward over the spaces til we see a nonspace
+ (possibly the equals). */
if (p > val)
while (*val == ' ')
val++;
/* Now if the = is after the char following the spaces,
- take the char following the spaces. */
+ take the char following the spaces. */
if (p > val)
p = val - 1;
}
std::string var (arg, p - arg);
if (nullset)
{
- printf_filtered (_("Setting environment variable "
- "\"%s\" to null value.\n"),
- var.c_str ());
+ gdb_printf (_("Setting environment variable "
+ "\"%s\" to null value.\n"),
+ var.c_str ());
current_inferior ()->environment.set (var.c_str (), "");
}
else
if (var == 0)
{
/* If there is no argument, delete all environment variables.
- Ask for confirmation if reading from the terminal. */
+ Ask for confirmation if reading from the terminal. */
if (!from_tty || query (_("Delete all environment variables? ")))
current_inferior ()->environment.clear ();
}
static void
path_info (const char *args, int from_tty)
{
- puts_filtered ("Executable and object file path: ");
- puts_filtered (current_inferior ()->environment.get (path_var_name));
- puts_filtered ("\n");
+ gdb_puts ("Executable and object file path: ");
+ gdb_puts (current_inferior ()->environment.get (path_var_name));
+ gdb_puts ("\n");
}
/* Add zero or more directories to the front of the execution path. */
static void
path_command (const char *dirname, int from_tty)
{
- char *exec_path;
const char *env;
dont_repeat ();
/* Can be null if path is not set. */
if (!env)
env = "";
- exec_path = xstrdup (env);
- mod_path (dirname, &exec_path);
- current_inferior ()->environment.set (path_var_name, exec_path);
- xfree (exec_path);
+ std::string exec_path = env;
+ mod_path (dirname, exec_path);
+ current_inferior ()->environment.set (path_var_name, exec_path.c_str ());
if (from_tty)
path_info (NULL, from_tty);
}
{
value_column_1 = 15,
/* Give enough room for "0x", 16 hex digits and two spaces in
- preceding column. */
+ preceding column. */
value_column_2 = value_column_1 + 2 + 16 + 2,
};
|| regtype->code () == TYPE_CODE_DECFLOAT)
{
struct value_print_options opts;
- const gdb_byte *valaddr = value_contents_for_printing (val);
+ const gdb_byte *valaddr = value_contents_for_printing (val).data ();
enum bfd_endian byte_order = type_byte_order (regtype);
get_user_print_options (&opts);
common_val_print (val, &format_stream, 0, &opts, current_language);
/* If not a vector register, print it also according to its
natural format. */
- if (print_raw_format && TYPE_VECTOR (regtype) == 0)
+ if (print_raw_format && regtype->is_vector () == 0)
{
pad_to_column (format_stream, value_column_2);
get_user_print_options (&opts);
}
}
- fputs_filtered (format_stream.c_str (), file);
- fprintf_filtered (file, "\n");
+ gdb_puts (format_stream.c_str (), file);
+ gdb_printf (file, "\n");
}
/* Print out the machine register regnum. If regnum is -1, print all
for (i = 0; i < numregs; i++)
{
/* Decide between printing all regs, non-float / vector regs, or
- specific reg. */
+ specific reg. */
if (regnum == -1)
{
if (print_all)
}
/* If the register name is empty, it is undefined for this
- processor, so don't display anything. */
+ processor, so don't display anything. */
if (gdbarch_register_name (gdbarch, i) == NULL
|| *(gdbarch_register_name (gdbarch, i)) == '\0')
continue;
struct frame_info *frame;
struct gdbarch *gdbarch;
- if (!target_has_registers)
+ if (!target_has_registers ())
error (_("The program has no registers now."));
frame = get_selected_frame (NULL);
gdbarch = get_frame_arch (frame);
addr_exp = skip_spaces (addr_exp);
/* Discard any leading ``$''. Check that there is something
- resembling a register following it. */
+ resembling a register following it. */
if (addr_exp[0] == '$')
addr_exp++;
if (isspace ((*addr_exp)) || (*addr_exp) == '\0')
}
}
if (!printed_something)
- fprintf_filtered (file, "No vector information\n");
+ gdb_printf (file, "No vector information\n");
}
}
static void
info_vector_command (const char *args, int from_tty)
{
- if (!target_has_registers)
+ if (!target_has_registers ())
error (_("The program has no registers now."));
print_vector_info (gdb_stdout, get_selected_frame (NULL), args);
int infnum = current_inferior ()->num;
target_kill ();
+ bfd_cache_close_all ();
if (print_inferior_events)
- printf_unfiltered (_("[Inferior %d (%s) killed]\n"),
- infnum, pid_str.c_str ());
-
- bfd_cache_close_all ();
+ gdb_printf (_("[Inferior %d (%s) killed]\n"),
+ infnum, pid_str.c_str ());
}
/* Used in `attach&' command. Proceed threads of inferior INF iff
scoped_restore_current_thread restore_thread;
for (thread_info *thread : inf->non_exited_threads ())
- if (!thread->executing
+ if (!thread->executing ()
&& !thread->stop_requested
- && thread->suspend.stop_signal == GDB_SIGNAL_0)
+ && thread->stop_signal () == GDB_SIGNAL_0)
{
switch_to_thread (thread);
clear_proceed_status (0);
else
{
reopen_exec_file ();
- reread_symbols ();
+ reread_symbols (from_tty);
}
/* Take any necessary post-attaching actions for this platform. */
target_post_attach (inferior_ptid.pid ());
- post_create_inferior (current_top_target (), from_tty);
+ post_create_inferior (from_tty);
}
/* What to do after the first program stops after attaching. */
};
/* Called after we've attached to a process and we've seen it stop for
- the first time. If ASYNC_EXEC is true, re-resume threads that
- should be running. Else if ATTACH, */
+ the first time. Resume, stop, or don't touch the threads according
+ to MODE. */
static void
-attach_post_wait (const char *args, int from_tty, enum attach_post_wait_mode mode)
+attach_post_wait (int from_tty, enum attach_post_wait_mode mode)
{
struct inferior *inferior;
/* The user requested an `attach&', so be sure to leave threads
that didn't get a signal running. */
- /* Immediatelly resume all suspended threads of this inferior,
+ /* Immediately resume all suspended threads of this inferior,
and this inferior only. This should have no effect on
already running threads. If a thread has been stopped with a
signal, leave it be. */
proceed_after_attach (inferior);
else
{
- if (inferior_thread ()->suspend.stop_signal == GDB_SIGNAL_0)
+ if (inferior_thread ()->stop_signal () == GDB_SIGNAL_0)
{
clear_proceed_status (0);
proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT);
{
struct thread_info *lowest = inferior_thread ();
- stop_all_threads ();
+ stop_all_threads ("attaching");
/* It's not defined which thread will report the attach
stop. For consistency, always select the thread with
}
}
-struct attach_command_continuation_args
-{
- char *args;
- int from_tty;
- enum attach_post_wait_mode mode;
-};
-
-static void
-attach_command_continuation (void *args, int err)
-{
- struct attach_command_continuation_args *a
- = (struct attach_command_continuation_args *) args;
-
- if (err)
- return;
-
- attach_post_wait (a->args, a->from_tty, a->mode);
-}
-
-static void
-attach_command_continuation_free_args (void *args)
-{
- struct attach_command_continuation_args *a
- = (struct attach_command_continuation_args *) args;
-
- xfree (a->args);
- xfree (a);
-}
-
/* "attach" command entry point. Takes a program started up outside
of gdb and ``attaches'' to it. This stops it cold in its tracks
and allows us to start debugging it. */
dont_repeat (); /* Not for the faint of heart */
+ scoped_disable_commit_resumed disable_commit_resumed ("attaching");
+
if (gdbarch_has_global_solist (target_gdbarch ()))
/* Don't complain if all processes share the same symbol
space. */
;
- else if (target_has_execution)
+ else if (target_has_execution ())
{
if (query (_("A program is being debugged already. Kill it? ")))
target_kill ();
shouldn't refer to attach_target again. */
attach_target = NULL;
+ if (debug_infrun)
+ {
+ infrun_debug_printf ("immediately after attach:");
+ for (thread_info *thread : inferior->non_exited_threads ())
+ infrun_debug_printf (" thread %s, executing = %d, resumed = %d, "
+ "state = %s",
+ thread->ptid.to_string ().c_str (),
+ thread->executing (),
+ thread->resumed (),
+ thread_state_string (thread->state));
+ }
+
+ /* Enable async mode if it is supported by the target. */
+ if (target_can_async_p ())
+ target_async (1);
+
/* Set up the "saved terminal modes" of the inferior
based on what modes we are starting it with. */
target_terminal::init ();
/* Set up execution context to know that we should return from
wait_for_inferior as soon as the target reports a stop. */
init_wait_for_inferior ();
- clear_proceed_status (0);
inferior->needs_setup = 1;
E.g. Mach 3 or GNU hurd. */
if (!target_attach_no_wait ())
{
- struct attach_command_continuation_args *a;
-
/* Careful here. See comments in inferior.h. Basically some
OSes don't ignore SIGSTOPs on continue requests anymore. We
need a way for handle_inferior_event to reset the stop_signal
inferior->control.stop_soon = STOP_QUIETLY_NO_SIGSTOP;
/* Wait for stop. */
- a = XNEW (struct attach_command_continuation_args);
- a->args = xstrdup (args);
- a->from_tty = from_tty;
- a->mode = mode;
- add_inferior_continuation (attach_command_continuation, a,
- attach_command_continuation_free_args);
+ inferior->add_continuation ([=] ()
+ {
+ attach_post_wait (from_tty, mode);
+ });
/* Let infrun consider waiting for events out of this
target. */
return;
}
else
- attach_post_wait (args, from_tty, mode);
+ attach_post_wait (from_tty, mode);
+
+ disable_commit_resumed.reset_and_commit ();
}
/* We had just found out that the target was already attached to an
as stopped. */
void
-notice_new_inferior (thread_info *thr, int leave_running, int from_tty)
+notice_new_inferior (thread_info *thr, bool leave_running, int from_tty)
{
enum attach_post_wait_mode mode
= leave_running ? ATTACH_POST_WAIT_RESUME : ATTACH_POST_WAIT_NOTHING;
/* When we "notice" a new inferior we need to do all the things we
would normally do if we had just attached to it. */
- if (thr->executing)
+ if (thr->executing ())
{
- struct attach_command_continuation_args *a;
struct inferior *inferior = current_inferior ();
/* We're going to install breakpoints, and poke at memory,
inferior->control.stop_soon = STOP_QUIETLY_REMOTE;
/* Wait for stop before proceeding. */
- a = XNEW (struct attach_command_continuation_args);
- a->args = xstrdup ("");
- a->from_tty = from_tty;
- a->mode = mode;
- add_inferior_continuation (attach_command_continuation, a,
- attach_command_continuation_free_args);
+ inferior->add_continuation ([=] ()
+ {
+ attach_post_wait (from_tty, mode);
+ });
return;
}
- attach_post_wait ("" /* args */, from_tty, mode);
+ attach_post_wait (from_tty, mode);
}
/*
if (inferior_ptid == null_ptid)
error (_("The program is not being run."));
+ scoped_disable_commit_resumed disable_commit_resumed ("detaching");
+
query_if_trace_running (from_tty);
disconnect_tracing ();
+ /* Hold a strong reference to the target while (maybe)
+ detaching the parent. Otherwise detaching could close the
+ target. */
+ auto target_ref
+ = target_ops_ref::new_reference (current_inferior ()->process_target ());
+
+ /* Save this before detaching, since detaching may unpush the
+ process_stratum target. */
+ bool was_non_stop_p = target_is_non_stop_p ();
+
target_detach (current_inferior (), from_tty);
/* The current inferior process was just detached successfully. Get
if (deprecated_detach_hook)
deprecated_detach_hook ();
+
+ if (!was_non_stop_p)
+ restart_after_all_stop_detach (as_process_stratum_target (target_ref.get ()));
+
+ disable_commit_resumed.reset_and_commit ();
}
/* Disconnect from the current target without resuming it (leaving it
void
interrupt_target_1 (bool all_threads)
{
+ scoped_disable_commit_resumed disable_commit_resumed ("interrupting");
+
if (non_stop)
{
if (all_threads)
}
else
target_interrupt ();
+
+ disable_commit_resumed.reset_and_commit ();
}
/* interrupt [-a]
}
}
if (!printed_something)
- fprintf_filtered (file, "No floating-point info "
- "available for this processor.\n");
+ gdb_printf (file, "No floating-point info "
+ "available for this processor.\n");
}
static void
{
struct frame_info *frame;
- if (!target_has_registers)
+ if (!target_has_registers ())
error (_("The program has no registers now."));
frame = get_selected_frame (NULL);
struct cmd_list_element *c,
const char *value)
{
- fprintf_filtered (file, _("\
+ gdb_printf (file, _("\
Printing of return value after `finish' is %s.\n"),
- value);
+ value);
}
add_basic_prefix_cmd ("unset", no_class,
_("Complement to certain \"set\" commands."),
- &unsetlist, "unset ", 0, &cmdlist);
+ &unsetlist, 0, &cmdlist);
c = add_cmd ("environment", class_run, unset_environment_command, _("\
Cancel environment variable VAR for the program.\n\
add_prefix_cmd ("kill", class_run, kill_command,
_("Kill execution of program being debugged."),
- &killlist, "kill ", 0, &cmdlist);
+ &killlist, 0, &cmdlist);
add_com ("attach", class_run, attach_command, _("\
Attach to a process or file outside of GDB.\n\
Detach a process or file previously attached.\n\
If a process, it is no longer traced, and it continues its execution. If\n\
you were debugging a file, the file is closed and gdb no longer accesses it."),
- &detachlist, "detach ", 0, &cmdlist);
+ &detachlist, 0, &cmdlist);
add_com ("disconnect", class_run, disconnect_command, _("\
Disconnect from a target.\n\
the current thread only."));
set_cmd_completer (c, signal_completer);
- add_com ("stepi", class_run, stepi_command, _("\
+ cmd_list_element *stepi_cmd
+ = add_com ("stepi", class_run, stepi_command, _("\
Step one instruction exactly.\n\
Usage: stepi [N]\n\
Argument N means step N times (or till program stops for another \
reason)."));
- add_com_alias ("si", "stepi", class_run, 0);
+ add_com_alias ("si", stepi_cmd, class_run, 0);
- add_com ("nexti", class_run, nexti_command, _("\
+ cmd_list_element *nexti_cmd
+ = add_com ("nexti", class_run, nexti_command, _("\
Step one instruction, but proceed through subroutine calls.\n\
Usage: nexti [N]\n\
Argument N means step N times (or till program stops for another \
reason)."));
- add_com_alias ("ni", "nexti", class_run, 0);
+ add_com_alias ("ni", nexti_cmd, class_run, 0);
- add_com ("finish", class_run, finish_command, _("\
+ cmd_list_element *finish_cmd
+ = add_com ("finish", class_run, finish_command, _("\
Execute until selected stack frame returns.\n\
Usage: finish\n\
Upon return, the value returned is printed and put in the value history."));
- add_com_alias ("fin", "finish", class_run, 1);
+ add_com_alias ("fin", finish_cmd, class_run, 1);
- add_com ("next", class_run, next_command, _("\
+ cmd_list_element *next_cmd
+ = add_com ("next", class_run, next_command, _("\
Step program, proceeding through subroutine calls.\n\
Usage: next [N]\n\
Unlike \"step\", if the current source line calls a subroutine,\n\
this command does not enter the subroutine, but instead steps over\n\
the call, in effect treating it as a single source line."));
- add_com_alias ("n", "next", class_run, 1);
+ add_com_alias ("n", next_cmd, class_run, 1);
- add_com ("step", class_run, step_command, _("\
+ cmd_list_element *step_cmd
+ = add_com ("step", class_run, step_command, _("\
Step program until it reaches a different source line.\n\
Usage: step [N]\n\
Argument N means step N times (or till program stops for another \
reason)."));
- add_com_alias ("s", "step", class_run, 1);
+ add_com_alias ("s", step_cmd, class_run, 1);
- c = add_com ("until", class_run, until_command, _("\
+ cmd_list_element *until_cmd
+ = add_com ("until", class_run, until_command, _("\
Execute until past the current line or past a LOCATION.\n\
Execute until the program reaches a source line greater than the current\n\
or a specified location (same args as break command) within the current \
frame."));
- set_cmd_completer (c, location_completer);
- add_com_alias ("u", "until", class_run, 1);
+ set_cmd_completer (until_cmd, location_completer);
+ add_com_alias ("u", until_cmd, class_run, 1);
c = add_com ("advance", class_run, advance_command, _("\
Continue the program up to the given location (same form as args for break \
Execution will also stop upon exit from the current stack frame."));
set_cmd_completer (c, location_completer);
- c = add_com ("jump", class_run, jump_command, _("\
+ cmd_list_element *jump_cmd
+ = add_com ("jump", class_run, jump_command, _("\
Continue program being debugged at specified line or address.\n\
Usage: jump LOCATION\n\
Give as argument either LINENUM or *ADDR, where ADDR is an expression\n\
for an address to start at."));
- set_cmd_completer (c, location_completer);
- add_com_alias ("j", "jump", class_run, 1);
+ set_cmd_completer (jump_cmd, location_completer);
+ add_com_alias ("j", jump_cmd, class_run, 1);
- add_com ("continue", class_run, continue_command, _("\
+ cmd_list_element *continue_cmd
+ = add_com ("continue", class_run, continue_command, _("\
Continue program being debugged, after signal or breakpoint.\n\
Usage: continue [N]\n\
If proceeding from breakpoint, a number N may be used as an argument,\n\
otherwise all the threads in the program are continued. To \n\
continue all stopped threads in non-stop mode, use the -a option.\n\
Specifying -a and an ignore count simultaneously is an error."));
- add_com_alias ("c", "cont", class_run, 1);
- add_com_alias ("fg", "cont", class_run, 1);
+ add_com_alias ("c", continue_cmd, class_run, 1);
+ add_com_alias ("fg", continue_cmd, class_run, 1);
- c = add_com ("run", class_run, run_command, _("\
+ cmd_list_element *run_cmd
+ = add_com ("run", class_run, run_command, _("\
Start debugged program.\n"
RUN_ARGS_HELP));
- set_cmd_completer (c, filename_completer);
- add_com_alias ("r", "run", class_run, 1);
+ set_cmd_completer (run_cmd, filename_completer);
+ add_com_alias ("r", run_cmd, class_run, 1);
c = add_com ("start", class_run, start_command, _("\
Start the debugged program stopping at the beginning of the main procedure.\n"
otherwise all the threads in the program are stopped. To \n\
interrupt all running threads in non-stop mode, use the -a option."));
- c = add_info ("registers", info_registers_command, _("\
+ cmd_list_element *info_registers_cmd
+ = add_info ("registers", info_registers_command, _("\
List of integer registers and their contents, for selected stack frame.\n\
One or more register names as argument means describe the given registers.\n\
One or more register group names as argument means describe the registers\n\
in the named register groups."));
- add_info_alias ("r", "registers", 1);
- set_cmd_completer (c, reg_or_group_completer);
+ add_info_alias ("r", info_registers_cmd, 1);
+ set_cmd_completer (info_registers_cmd, reg_or_group_completer);
c = add_info ("all-registers", info_all_registers_command, _("\
List of all registers and their contents, for selected stack frame.\n\
_("\
Show additional information about a process.\n\
Specify any process id, or use the program being debugged by default."),
- &info_proc_cmdlist, "info proc ",
+ &info_proc_cmdlist,
1/*allow-unknown*/, &infolist);
add_cmd ("mappings", class_info, info_proc_cmd_mappings, _("\
projects / binutils-gdb.git / blobdiff