/* Memory-access and commands for "inferior" process, for GDB.
- Copyright (C) 1986-2021 Free Software Foundation, Inc.
+ Copyright (C) 1986-2022 Free Software Foundation, Inc.
This file is part of GDB.
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
{
/* Note that we ignore the passed-in value in favor of computing it
directly. */
- const char *inferior_tty = current_inferior ()->tty ();
+ const std::string &inferior_tty = current_inferior ()->tty ();
- if (inferior_tty == nullptr)
- inferior_tty = "";
- fprintf_filtered (gdb_stdout,
+ fprintf_filtered (file,
_("Terminal for future runs of program being debugged "
- "is \"%s\".\n"), inferior_tty);
-}
-
-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 = make_unique_xstrdup ("");
-
- return current_inferior ()->args.get ();
-}
-
-/* Set the arguments for the current inferior. Ownership of
- NEWARGS is not transferred. */
-
-void
-set_inferior_args (const char *newargs)
-{
- if (newargs != nullptr)
- current_inferior ()->args = make_unique_xstrdup (newargs);
- else
- current_inferior ()->args.reset ();
-
- current_inferior ()->argc = 0;
- current_inferior ()->argv = 0;
+ "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 ())
+ fprintf_filtered (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,
+ fprintf_filtered (file,
_("Current working directory that will be used "
- "when starting the inferior is \"%s\".\n"), cwd);
+ "when starting the inferior is \"%s\".\n"),
+ cwd.c_str ());
}
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)
{
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 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)
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)
{
if (exec_file)
uiout->field_string ("execfile", exec_file);
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
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
/* 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;
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_signal_to_name (tp->stop_signal ()),
+ gdb_signal_to_string (tp->stop_signal ()));
must_confirm = 1;
}
}
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)
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");
}
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;
target_files_info ();
printf_filtered (_("Program stopped at %s.\n"),
- paddress (target_gdbarch (), tp->suspend.stop_pc));
+ paddress (target_gdbarch (), tp->stop_pc ()));
if (tp->control.stop_step)
printf_filtered (_("It stopped after being stepped.\n"));
else if (stat != 0)
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_signal_to_name (tp->stop_signal ()),
+ gdb_signal_to_string (tp->stop_signal ()));
}
if (from_tty)
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);
}
|| 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);
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 ();
+ printf_filtered (_("[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. */
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);
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));
+ }
+
/* Set up the "saved terminal modes" of the inferior
based on what modes we are starting it with. */
target_terminal::init ();
/* 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 inferior *inferior = current_inferior ();
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