/* Memory-access and commands for "inferior" process, for GDB.
- Copyright (C) 1986-2023 Free Software Foundation, Inc.
+ Copyright (C) 1986-2024 Free Software Foundation, Inc.
This file is part of GDB.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. */
-#include "defs.h"
#include "arch-utils.h"
+#include "exceptions.h"
#include "symtab.h"
#include "gdbtypes.h"
#include "frame.h"
#include "infrun.h"
#include "gdbsupport/environ.h"
#include "value.h"
-#include "gdbcmd.h"
+#include "cli/cli-cmds.h"
#include "symfile.h"
#include "gdbcore.h"
#include "target.h"
#include "inf-loop.h"
#include "linespec.h"
#include "thread-fsm.h"
-#include "top.h"
+#include "ui.h"
#include "interps.h"
#include "skip.h"
-#include "gdbsupport/gdb_optional.h"
+#include <optional>
#include "source.h"
#include "cli/cli-style.h"
-#include "dwarf2/loc.h"
/* Local functions: */
#define ERROR_NO_INFERIOR \
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
- stored, notice_args_set will move it into per-inferior storage.
- Arguments are separated by spaces. Empty string (pointer to '\0')
- means no args. */
-
-static std::string inferior_args_scratch;
-
-/* Scratch area where the new cwd will be stored by 'set cwd'. */
-
-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 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
being debugged it should be nonzero (currently 3 is used) for remote
\f
+/* Store the new value passed to 'set inferior-tty'. */
+
static void
-set_inferior_tty_command (const char *args, int from_tty,
- struct cmd_list_element *c)
+set_tty_value (const std::string &tty)
+{
+ current_inferior ()->set_tty (tty);
+}
+
+/* Get the current 'inferior-tty' value. */
+
+static const std::string &
+get_tty_value ()
{
- /* CLI has assigned the user-provided value to inferior_io_terminal_scratch.
- Now route it to current inferior. */
- current_inferior ()->set_tty (inferior_io_terminal_scratch);
+ return current_inferior ()->tty ();
}
+/* Implement 'show inferior-tty' command. */
+
static void
show_inferior_tty_command (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
"is \"%s\".\n"), inferior_tty.c_str ());
}
-void
-set_inferior_args_vector (int argc, char **argv)
+/* Store the new value passed to 'set args'. */
+
+static void
+set_args_value (const std::string &args)
{
- gdb::array_view<char * const> args (argv, argc);
- std::string n = construct_inferior_arguments (args);
- current_inferior ()->set_args (std::move (n));
+ current_inferior ()->set_args (args);
}
-/* Notice when `set args' is run. */
+/* Return the value for 'show args' to display. */
-static void
-set_args_command (const char *args, int from_tty, struct cmd_list_element *c)
+static const std::string &
+get_args_value ()
{
- /* CLI has assigned the user-provided value to inferior_args_scratch.
- Now route it to current inferior. */
- current_inferior ()->set_args (inferior_args_scratch);
+ return current_inferior ()->args ();
}
-/* Notice when `show args' is run. */
+/* Callback to implement 'show args' command. */
static void
show_args_command (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
{
- /* Note that we ignore the passed-in value in favor of computing it
- directly. */
- deprecated_show_value_hack (file, from_tty, c,
- current_inferior ()->args ().c_str ());
+ /* Ignore the passed in value, pull the argument directly from the
+ inferior. However, these should always be the same. */
+ gdb_printf (file, _("\
+Argument list to give program being debugged when it is started is \"%s\".\n"),
+ current_inferior ()->args ().c_str ());
}
/* See gdbsupport/common-inferior.h. */
return current_inferior ()->cwd ();
}
-/* Handle the 'set cwd' command. */
+/* Store the new value passed to 'set cwd'. */
static void
-set_cwd_command (const char *args, int from_tty, struct cmd_list_element *c)
+set_cwd_value (const std::string &args)
{
- current_inferior ()->set_cwd (inferior_cwd_scratch);
+ current_inferior ()->set_cwd (args);
}
/* Handle the 'show cwd' command. */
/* If the solist is global across processes, there's no need to
refetch it here. */
- if (!gdbarch_has_global_solist (target_gdbarch ()))
+ if (!gdbarch_has_global_solist (current_inferior ()->arch ()))
solib_add (nullptr, 0, auto_solib_add);
}
}
if (run_how == RUN_STOP_AT_MAIN)
{
/* To avoid other inferiors hitting this breakpoint, make it
- inferior-specific using a condition. A better solution would be to
- have proper inferior-specific breakpoint support, in the breakpoint
- machinery. We could then avoid inserting a breakpoint in the program
- spaces unrelated to this inferior. */
- const char *op
- = ((current_language->la_language == language_ada
- || current_language->la_language == language_pascal
- || current_language->la_language == language_m2) ? "=" : "==");
- std::string arg = string_printf
- ("-qualified %s if $_inferior %s %d", main_name (), op,
- current_inferior ()->num);
+ inferior-specific. */
+ std::string arg = string_printf ("-qualified %s inferior %d",
+ main_name (),
+ current_inferior ()->num);
tbreak_command (arg.c_str (), 0);
}
/* Start the target running. Do not use -1 continuation as it would skip
breakpoint right at the entry point. */
- proceed (regcache_read_pc (get_current_regcache ()), GDB_SIGNAL_0);
+ proceed (regcache_read_pc (get_thread_regcache (inferior_thread ())),
+ GDB_SIGNAL_0);
/* Since there was no error, there's no need to finish the thread
states here. */
ptid_t last_ptid;
get_last_target_status (&last_target, &last_ptid, nullptr);
- tp = find_thread_ptid (last_target, last_ptid);
+ tp = last_target->find_thread (last_ptid);
}
if (tp != nullptr)
bs = tp->control.stop_bpstat;
}
}
- ERROR_NO_INFERIOR;
ensure_not_tfind_mode ();
if (!non_stop || !all_threads_p)
&tp->control.step_range_start,
&tp->control.step_range_end);
+ if (execution_direction == EXEC_REVERSE)
+ {
+ symtab_and_line sal = find_pc_line (pc, 0);
+ symtab_and_line sal_start
+ = find_pc_line (tp->control.step_range_start, 0);
+
+ if (sal.line == sal_start.line)
+ /* Executing in reverse, the step_range_start address is in
+ the same line. We want to stop in the previous line so
+ move step_range_start before the current line. */
+ tp->control.step_range_start--;
+ }
+
/* 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. */
error_no_arg (_("starting address"));
std::vector<symtab_and_line> sals
- = decode_line_with_last_displayed (arg, DECODE_LINE_FUNFIRSTLINE);
+ = decode_line_with_current_source (arg, DECODE_LINE_FUNFIRSTLINE);
if (sals.size () != 1)
- error (_("Unreasonable jump request"));
+ {
+ /* If multiple sal-objects were found, try dropping those that aren't
+ from the current symtab. */
+ struct symtab_and_line cursal = get_current_source_symtab_and_line ();
+ sals.erase (std::remove_if (sals.begin (), sals.end (),
+ [&] (const symtab_and_line &sal)
+ {
+ return sal.symtab != cursal.symtab;
+ }), sals.end ());
+ if (sals.size () != 1)
+ error (_("Jump request is ambiguous: "
+ "does not resolve to a single address"));
+ }
symtab_and_line &sal = sals[0];
/* See if we are trying to jump to another function. */
fn = get_frame_function (get_current_frame ());
- sfn = find_pc_function (sal.pc);
+ sfn = find_pc_sect_containing_function (sal.pc,
+ find_pc_mapped_section (sal.pc));
if (fn != nullptr && sfn != fn)
{
if (!query (_("Line %d is not in `%s'. Jump anyway? "), sal.line,
{
struct obj_section *section;
- fixup_symbol_section (sfn, 0);
section = sfn->obj_section (sfn->objfile ());
if (section_is_overlay (section)
&& !section_is_mapped (section))
tp->control.step_range_start = func->value_block ()->entry_pc ();
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;
struct value *
get_return_value (struct symbol *func_symbol, struct value *function)
{
- regcache *stop_regs = get_current_regcache ();
+ regcache *stop_regs = get_thread_regcache (inferior_thread ());
struct gdbarch *gdbarch = stop_regs->arch ();
struct value *value;
= check_typedef (func_symbol->type ()->target_type ());
gdb_assert (value_type->code () != TYPE_CODE_VOID);
- if (is_nocall_function (check_typedef (::value_type (function))))
+ if (is_nocall_function (check_typedef (function->type ())))
{
warning (_("Function '%s' does not follow the target calling "
"convention, cannot determine its returned value."),
return value;
}
-/* The captured function return value/type and its position in the
- value history. */
-
-struct return_value_info
-{
- /* The captured return value. May be NULL if we weren't able to
- retrieve it. See get_return_value. */
- struct value *value;
-
- /* The return type. In some cases, we'll not be able extract the
- return value, but we always know the type. */
- struct type *type;
-
- /* If we captured a value, this is the value history index. */
- int value_history_index;
-};
-
/* Helper for print_return_value. */
static void
delete the breakpoint. */
print_return_value_1 (uiout, rv);
}
- catch (const gdb_exception &ex)
+ catch (const gdb_exception_error &ex)
{
exception_print (gdb_stdout, ex);
}
rv->value = get_return_value (function, func);
if (rv->value != nullptr)
- rv->value_history_index = record_latest_value (rv->value);
+ rv->value_history_index = rv->value->record_latest ();
}
}
else if (tp->control.stop_step)
struct thread_info *tp = inferior_thread ();
CORE_ADDR pc;
CORE_ADDR func_addr;
+ CORE_ADDR alt_entry_point;
+ CORE_ADDR entry_point;
+ frame_info_ptr frame = get_selected_frame (nullptr);
+ struct gdbarch *gdbarch = get_frame_arch (frame);
pc = get_frame_pc (get_current_frame ());
error (_("Cannot find bounds of current function"));
sal = find_pc_line (func_addr, 0);
-
- frame_info_ptr frame = get_selected_frame (nullptr);
-
- if (sal.pc != pc)
- {
- struct gdbarch *gdbarch = get_frame_arch (frame);
-
- /* Set a step-resume at the function's entry point. Once that's
- hit, we'll do one more step backwards. */
+ alt_entry_point = sal.pc;
+ entry_point = alt_entry_point;
+
+ if (gdbarch_skip_entrypoint_p (gdbarch))
+ /* Some architectures, like PowerPC use local and global entry points.
+ There is only one Entry Point (GEP = LEP) for other architectures.
+ The GEP is an alternate entry point. The LEP is the normal entry point.
+ The value of entry_point was initialized to the alternate entry point
+ (GEP). It will be adjusted to the normal entry point if the function
+ has two entry points. */
+ entry_point = gdbarch_skip_entrypoint (gdbarch, sal.pc);
+
+ tp->control.proceed_to_finish = 1;
+ /* Special case: if we're sitting at the function entry point,
+ then all we need to do is take a reverse singlestep. We
+ don't need to set a breakpoint, and indeed it would do us
+ no good to do so.
+
+ Note that this can only happen at frame #0, since there's
+ no way that a function up the stack can have a return address
+ that's equal to its entry point. */
+
+ if ((pc < alt_entry_point) || (pc > entry_point))
+ {
+ /* We are in the body of the function. Set a breakpoint to go back to
+ the normal entry point. */
symtab_and_line sr_sal;
- sr_sal.pc = sal.pc;
+ sr_sal.pc = entry_point;
sr_sal.pspace = get_frame_program_space (frame);
insert_step_resume_breakpoint_at_sal (gdbarch,
sr_sal, null_frame_id);
+
+ proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT);
}
else
{
- /* We are exactly at the function entry point. Note that this
- can only happen at frame #0.
-
- When setting a step range, need to call set_step_info
- to setup the current_line/symtab fields as well. */
- set_step_info (tp, frame, find_pc_line (pc, 0));
-
- /* Return using a step range so we will keep stepping back
- to the first instruction in the source code line. */
- tp->control.step_range_start = sal.pc;
- tp->control.step_range_end = sal.pc;
+ /* We are either at one of the entry points or between the entry points.
+ If we are not at the alt_entry point, go back to the alt_entry_point
+ If we at the normal entry point step back one instruction, when we
+ stop we will determine if we entered via the entry point or the
+ alternate entry point. If we are at the alternate entry point,
+ single step back to the function call. */
+ tp->control.step_range_start = tp->control.step_range_end = 1;
+ proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT);
}
- proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT);
}
/* finish_forward -- helper function for finish_command. FRAME is the
frame that called the function we're about to step out of. */
static void
-finish_forward (struct finish_command_fsm *sm, frame_info_ptr frame)
+finish_forward (struct finish_command_fsm *sm, const frame_info_ptr &frame)
{
struct frame_id frame_id = get_frame_id (frame);
struct gdbarch *gdbarch = get_frame_arch (frame);
get_stack_frame_id (frame),
bp_finish);
- /* set_momentary_breakpoint invalidates FRAME. */
- frame = nullptr;
-
set_longjmp_breakpoint (tp, frame_id);
+ /* We want to print return value, please... */
+ tp->control.proceed_to_finish = 1;
+
proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT);
}
/* Skip frames for "finish". */
static frame_info_ptr
-skip_finish_frames (frame_info_ptr frame)
+skip_finish_frames (const frame_info_ptr &initial_frame)
{
frame_info_ptr start;
+ frame_info_ptr frame = initial_frame;
do
{
frame = get_prev_frame (get_selected_frame (_("No selected frame.")));
if (frame == 0)
error (_("\"finish\" not meaningful in the outermost frame."));
- frame.prepare_reinflate ();
clear_proceed_status (0);
print_stack_frame (callee_frame, 1, LOCATION, 0);
}
- frame.reinflate ();
if (execution_direction == EXEC_REVERSE)
finish_backward (sm);
static void
info_program_command (const char *args, int from_tty)
{
- bpstat *bs;
- int num, stat;
- ptid_t ptid;
- process_stratum_target *proc_target;
+ scoped_restore_current_thread restore_thread;
- if (!target_has_execution ())
- {
- gdb_printf (_("The program being debugged is not being run.\n"));
- return;
- }
+ thread_info *tp;
+
+ /* In non-stop, since every thread is controlled individually, we'll
+ show execution info about the current thread. In all-stop, we'll
+ show execution info about the last stop. */
if (non_stop)
{
- ptid = inferior_ptid;
- proc_target = current_inferior ()->process_target ();
+ if (!target_has_execution ())
+ {
+ gdb_printf (_("The program being debugged is not being run.\n"));
+ return;
+ }
+
+ if (inferior_ptid == null_ptid)
+ error (_("No selected thread."));
+
+ tp = inferior_thread ();
+
+ gdb_printf (_("Selected thread %s (%s).\n"),
+ print_thread_id (tp),
+ target_pid_to_str (tp->ptid).c_str ());
+
+ if (tp->state == THREAD_EXITED)
+ {
+ gdb_printf (_("Selected thread has exited.\n"));
+ return;
+ }
+ else if (tp->state == THREAD_RUNNING)
+ {
+ gdb_printf (_("Selected thread is running.\n"));
+ return;
+ }
}
else
- get_last_target_status (&proc_target, &ptid, nullptr);
+ {
+ tp = get_previous_thread ();
+
+ if (tp == nullptr)
+ {
+ gdb_printf (_("The program being debugged is not being run.\n"));
+ return;
+ }
- if (ptid == null_ptid || ptid == minus_one_ptid)
- error (_("No selected thread."));
+ switch_to_thread (tp);
- thread_info *tp = find_thread_ptid (proc_target, ptid);
+ gdb_printf (_("Last stopped for thread %s (%s).\n"),
+ print_thread_id (tp),
+ target_pid_to_str (tp->ptid).c_str ());
- if (tp->state == THREAD_EXITED)
- error (_("Invalid selected thread."));
- else if (tp->state == THREAD_RUNNING)
- error (_("Selected thread is running."));
+ if (tp->state == THREAD_EXITED)
+ {
+ gdb_printf (_("Thread has since exited.\n"));
+ return;
+ }
+
+ if (tp->state == THREAD_RUNNING)
+ {
+ gdb_printf (_("Thread is now running.\n"));
+ return;
+ }
+ }
- bs = tp->control.stop_bpstat;
- stat = bpstat_num (&bs, &num);
+ int num;
+ bpstat *bs = tp->control.stop_bpstat;
+ int stat = bpstat_num (&bs, &num);
target_files_info ();
gdb_printf (_("Program stopped at %s.\n"),
- paddress (target_gdbarch (), tp->stop_pc ()));
+ paddress (current_inferior ()->arch (), tp->stop_pc ()));
if (tp->control.stop_step)
gdb_printf (_("It stopped after being stepped.\n"));
else if (stat != 0)
const char *name,
struct value *val)
{
- struct type *regtype = value_type (val);
+ struct type *regtype = val->type ();
int print_raw_format;
string_file format_stream;
enum tab_stops
format_stream.puts (name);
pad_to_column (format_stream, value_column_1);
- print_raw_format = (value_entirely_available (val)
- && !value_optimized_out (val));
+ print_raw_format = (val->entirely_available ()
+ && !val->optimized_out ());
/* If virtual format is floating, print it that way, and in raw
hex. */
|| regtype->code () == TYPE_CODE_DECFLOAT)
{
struct value_print_options opts;
- const gdb_byte *valaddr = value_contents_for_printing (val).data ();
+ const gdb_byte *valaddr = val->contents_for_printing ().data ();
enum bfd_endian byte_order = type_byte_order (regtype);
get_user_print_options (&opts);
void
default_print_registers_info (struct gdbarch *gdbarch,
struct ui_file *file,
- frame_info_ptr frame,
+ const frame_info_ptr &frame,
int regnum, int print_all)
{
int i;
if (*(gdbarch_register_name (gdbarch, i)) == '\0')
continue;
- default_print_one_register_info (file,
- gdbarch_register_name (gdbarch, i),
- value_of_register (i, frame));
+ default_print_one_register_info
+ (file, gdbarch_register_name (gdbarch, i),
+ value_of_register (i, get_next_frame_sentinel_okay (frame)));
}
}
static void
print_vector_info (struct ui_file *file,
- frame_info_ptr frame, const char *args)
+ const frame_info_ptr &frame, const char *args)
{
struct gdbarch *gdbarch = get_frame_arch (frame);
int infnum = current_inferior ()->num;
target_kill ();
- bfd_cache_close_all ();
+
+ update_previous_thread ();
if (print_inferior_events)
gdb_printf (_("[Inferior %d (%s) killed]\n"),
scoped_disable_commit_resumed disable_commit_resumed ("attaching");
- if (gdbarch_has_global_solist (target_gdbarch ()))
+ if (gdbarch_has_global_solist (current_inferior ()->arch ()))
/* Don't complain if all processes share the same symbol
space. */
;
enum attach_post_wait_mode mode
= leave_running ? ATTACH_POST_WAIT_RESUME : ATTACH_POST_WAIT_NOTHING;
- gdb::optional<scoped_restore_current_thread> restore_thread;
+ std::optional<scoped_restore_current_thread> restore_thread;
if (inferior_ptid != null_ptid)
restore_thread.emplace ();
/* 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 ());
+ inferior *inf = current_inferior ();
+ auto target_ref = target_ops_ref::new_reference (inf->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);
+ target_detach (inf, from_tty);
+
+ update_previous_thread ();
/* The current inferior process was just detached successfully. Get
rid of breakpoints that no longer make sense. Note we don't do
this within target_detach because that is also used when
following child forks, and in that case we will want to transfer
breakpoints to the child, not delete them. */
- breakpoint_init_inferior (inf_exited);
+ breakpoint_init_inferior (inf, inf_exited);
/* If the solist is global across inferiors, don't clear it when we
detach from a single inferior. */
- if (!gdbarch_has_global_solist (target_gdbarch ()))
+ if (!gdbarch_has_global_solist (inf->arch ()))
no_shared_libraries (nullptr, from_tty);
if (deprecated_detach_hook)
target_disconnect (args, from_tty);
no_shared_libraries (nullptr, from_tty);
init_thread_list ();
+ update_previous_thread ();
if (deprecated_detach_hook)
deprecated_detach_hook ();
}
void
default_print_float_info (struct gdbarch *gdbarch, struct ui_file *file,
- frame_info_ptr frame, const char *args)
+ const frame_info_ptr &frame, const char *args)
{
int regnum;
int printed_something = 0;
variable). Input and output redirection with \">\", \"<\", or \">>\"\n\
are also allowed.\n\
\n\
-With no arguments, uses arguments last specified (with \"run\" or \n\
+With no arguments, uses arguments last specified (with \"run\" or\n\
\"set args\"). To cancel previous arguments and run with no arguments,\n\
use \"set args\" without arguments.\n\
\n\
{
static struct cmd_list_element *info_proc_cmdlist;
struct cmd_list_element *c = nullptr;
- const char *cmd_name;
/* Add the filename of the terminal connected to inferior I/O. */
- add_setshow_optional_filename_cmd ("inferior-tty", class_run,
- &inferior_io_terminal_scratch, _("\
+ auto tty_set_show
+ = add_setshow_optional_filename_cmd ("inferior-tty", class_run, _("\
Set terminal for future runs of program being debugged."), _("\
Show terminal for future runs of program being debugged."), _("\
Usage: set inferior-tty [TTY]\n\n\
If TTY is omitted, the default behavior of using the same terminal as GDB\n\
is restored."),
- set_inferior_tty_command,
- show_inferior_tty_command,
- &setlist, &showlist);
- cmd_name = "inferior-tty";
- c = lookup_cmd (&cmd_name, setlist, "", nullptr, -1, 1);
- gdb_assert (c != nullptr);
- add_alias_cmd ("tty", c, class_run, 0, &cmdlist);
-
- cmd_name = "args";
- add_setshow_string_noescape_cmd (cmd_name, class_run,
- &inferior_args_scratch, _("\
+ set_tty_value,
+ get_tty_value,
+ show_inferior_tty_command,
+ &setlist, &showlist);
+ add_alias_cmd ("tty", tty_set_show.set, class_run, 0, &cmdlist);
+
+ auto args_set_show
+ = add_setshow_string_noescape_cmd ("args", class_run, _("\
Set argument list to give program being debugged when it is started."), _("\
Show argument list to give program being debugged when it is started."), _("\
Follow this command with any number of args, to be passed to the program."),
- set_args_command,
- show_args_command,
- &setlist, &showlist);
- c = lookup_cmd (&cmd_name, setlist, "", nullptr, -1, 1);
- gdb_assert (c != nullptr);
- set_cmd_completer (c, filename_completer);
-
- cmd_name = "cwd";
- add_setshow_string_noescape_cmd (cmd_name, class_run,
- &inferior_cwd_scratch, _("\
+ set_args_value,
+ get_args_value,
+ show_args_command,
+ &setlist, &showlist);
+ set_cmd_completer (args_set_show.set, filename_completer);
+
+ auto cwd_set_show
+ = add_setshow_string_noescape_cmd ("cwd", class_run, _("\
Set the current working directory to be used when the inferior is started.\n\
Changing this setting does not have any effect on inferiors that are\n\
already running."),
- _("\
+ _("\
Show the current working directory that is used when the inferior is started."),
- _("\
+ _("\
Use this command to change the current working directory that will be used\n\
when the inferior is started. This setting does not affect GDB's current\n\
working directory."),
- set_cwd_command,
- show_cwd_command,
- &setlist, &showlist);
- c = lookup_cmd (&cmd_name, setlist, "", nullptr, -1, 1);
- gdb_assert (c != nullptr);
- set_cmd_completer (c, filename_completer);
+ set_cwd_value, get_inferior_cwd,
+ show_cwd_command,
+ &setlist, &showlist);
+ set_cmd_completer (cwd_set_show.set, filename_completer);
c = add_cmd ("environment", no_class, environment_info, _("\
The environment to give the program, or one variable's value.\n\
the breakpoint won't break until the Nth time it is reached).\n\
\n\
If non-stop mode is enabled, continue only the current thread,\n\
-otherwise all the threads in the program are continued. To \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", continue_cmd, class_run, 1);
add_com ("interrupt", class_run, interrupt_command,
_("Interrupt the execution of the debugged program.\n\
If non-stop mode is enabled, interrupt only the current thread,\n\
-otherwise all the threads in the program are stopped. To \n\
+otherwise all the threads in the program are stopped. To\n\
interrupt all running threads in non-stop mode, use the -a option."));
cmd_list_element *info_registers_cmd