-/* Memory-access and commands for "inferior" (child) process, for GDB.
- Copyright 1986, 1987, 1988, 1989, 1991, 1992 Free Software Foundation, Inc.
+/* Memory-access and commands for "inferior" process, for GDB.
+ Copyright 1986, 87, 88, 89, 91, 92, 95, 96, 1998
+ 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, write to the Free Software
-Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
#include "defs.h"
#include <signal.h>
-#include <sys/param.h>
-#include <string.h>
+#include "gdb_string.h"
#include "symtab.h"
#include "gdbtypes.h"
#include "frame.h"
#include "gdbcore.h"
#include "target.h"
#include "language.h"
+#include "symfile.h"
+#include "objfiles.h"
-static void
-continue_command PARAMS ((char *, int));
+/* Functions exported for general use: */
-static void
-until_next_command PARAMS ((int));
+void nofp_registers_info PARAMS ((char *, int));
-static void
-until_command PARAMS ((char *, int));
+void all_registers_info PARAMS ((char *, int));
-static void
-path_info PARAMS ((char *, int));
+void registers_info PARAMS ((char *, int));
-static void
-path_command PARAMS ((char *, int));
+/* Local functions: */
-static void
-unset_command PARAMS ((char *, int));
+void continue_command PARAMS ((char *, int));
-static void
-float_info PARAMS ((char *, int));
+static void until_next_command PARAMS ((int));
-static void
-detach_command PARAMS ((char *, int));
+static void until_command PARAMS ((char *, int));
-static void
-nofp_registers_info PARAMS ((char *, int));
+static void path_info PARAMS ((char *, int));
-static void
-all_registers_info PARAMS ((char *, int));
+static void path_command PARAMS ((char *, int));
-static void
-registers_info PARAMS ((char *, int));
+static void unset_command PARAMS ((char *, int));
-static void
-do_registers_info PARAMS ((int, int));
+static void float_info PARAMS ((char *, int));
-static void
-unset_environment_command PARAMS ((char *, int));
+static void detach_command PARAMS ((char *, int));
-static void
-set_environment_command PARAMS ((char *, int));
+#if !defined (DO_REGISTERS_INFO)
+static void do_registers_info PARAMS ((int, int));
+#endif
-static void
-environment_info PARAMS ((char *, int));
+static void unset_environment_command PARAMS ((char *, int));
-static void
-program_info PARAMS ((char *, int));
+static void set_environment_command PARAMS ((char *, int));
-static void
-finish_command PARAMS ((char *, int));
+static void environment_info PARAMS ((char *, int));
-static void
-signal_command PARAMS ((char *, int));
+static void program_info PARAMS ((char *, int));
-static void
-jump_command PARAMS ((char *, int));
+static void finish_command PARAMS ((char *, int));
-static void
-step_1 PARAMS ((int, int, char *));
+static void signal_command PARAMS ((char *, int));
-static void
-nexti_command PARAMS ((char *, int));
+static void jump_command PARAMS ((char *, int));
-static void
-stepi_command PARAMS ((char *, int));
+static void step_1 PARAMS ((int, int, char *));
-static void
-next_command PARAMS ((char *, int));
+void nexti_command PARAMS ((char *, int));
-static void
-step_command PARAMS ((char *, int));
+void stepi_command PARAMS ((char *, int));
-static void
-run_command PARAMS ((char *, int));
+static void next_command PARAMS ((char *, int));
+
+static void step_command PARAMS ((char *, int));
+
+static void run_command PARAMS ((char *, int));
+
+void _initialize_infcmd PARAMS ((void));
+
+#define GO_USAGE "Usage: go <location>\n"
+
+static void breakpoint_auto_delete_contents PARAMS ((PTR));
#define ERROR_NO_INFERIOR \
if (!target_has_execution) error ("The program is not being run.");
This is how we know when we step into a subroutine call,
and how to set the frame for the breakpoint used to step out. */
-FRAME_ADDR step_frame_address;
+CORE_ADDR step_frame_address;
/* Our notion of the current stack pointer. */
dont_repeat ();
- if (inferior_pid)
+ if (inferior_pid != 0 && target_has_execution)
{
if (
!query ("The program being debugged has been started already.\n\
Start it from the beginning? "))
error ("Program not restarted.");
target_kill ();
+#if defined(SOLIB_RESTART)
+ SOLIB_RESTART ();
+#endif
+ init_wait_for_inferior ();
}
clear_breakpoint_hit_counts ();
exec_file = (char *) get_exec_file (0);
+ /* Purge old solib objfiles. */
+ objfile_purge_solibs ();
+
+ do_run_cleanups (NULL);
+
/* The exec file is re-read every time we do a generic_mourn_inferior, so
we just have to worry about the symbol file. */
reread_symbols ();
target_create_inferior (exec_file, inferior_args,
environ_vector (inferior_environ));
}
-\f
+
+
static void
+run_no_args_command (args, from_tty)
+ char *args;
+ int from_tty;
+{
+ execute_command("set args", from_tty);
+ run_command((char *)NULL, from_tty);
+}
+
+\f
+void
continue_command (proc_count_exp, from_tty)
char *proc_count_exp;
int from_tty;
/* Likewise, but step only one instruction. */
/* ARGSUSED */
-static void
+void
stepi_command (count_string, from_tty)
char *count_string;
int from_tty;
}
/* ARGSUSED */
-static void
+void
nexti_command (count_string, from_tty)
char *count_string;
int from_tty;
char *count_string;
{
register int count = 1;
- FRAME fr;
+ struct frame_info *frame;
struct cleanup *cleanups = 0;
ERROR_NO_INFERIOR;
if (!single_inst || skip_subroutines) /* leave si command alone */
{
enable_longjmp_breakpoint();
- cleanups = make_cleanup(disable_longjmp_breakpoint, 0);
+ cleanups = make_cleanup ((make_cleanup_func) disable_longjmp_breakpoint,
+ 0);
}
for (; count > 0; count--)
{
clear_proceed_status ();
- fr = get_current_frame ();
- if (!fr) /* Avoid coredump here. Why tho? */
+ frame = get_current_frame ();
+ if (!frame) /* Avoid coredump here. Why tho? */
error ("No current frame");
- step_frame_address = FRAME_FP (fr);
+ step_frame_address = FRAME_FP (frame);
step_sp = read_sp ();
if (! single_inst)
printf_filtered ("\
Single stepping until exit from function %s, \n\
which has no line number information.\n", name);
- gdb_flush (gdb_stdout);
}
}
else
}
}
+ if (sfn != NULL)
+ {
+ fixup_symbol_section (sfn, 0);
+ if (section_is_overlay (SYMBOL_BFD_SECTION (sfn)) &&
+ !section_is_mapped (SYMBOL_BFD_SECTION (sfn)))
+ {
+ if (!query ("WARNING!!! Destination is in unmapped overlay! Jump anyway? "))
+ {
+ error ("Not confirmed.");
+ /* NOTREACHED */
+ }
+ }
+ }
+
+
addr = sal.pc;
if (from_tty)
proceed (addr, TARGET_SIGNAL_0, 0);
}
+\f
+/* Go to line or address in current procedure */
+static void
+go_command (line_no, from_tty)
+ char *line_no;
+ int from_tty;
+{
+ if (line_no == (char *)NULL || !*line_no)
+ printf_filtered (GO_USAGE);
+ else
+ {
+ tbreak_command (line_no, from_tty);
+ jump_command (line_no, from_tty);
+ }
+}
+
+\f
/* Continue program giving it specified signal. */
static void
if (oursig == TARGET_SIGNAL_UNKNOWN)
{
- /* Not found as a name, try it as an expression. */
- /* The numeric signal refers to our own internal signal numbering
- from target.h, not to host/target signal number. This is a
- feature; users really should be using symbolic names anyway,
- and the common ones like SIGHUP, SIGINT, SIGALRM, etc. will
- work right anyway. */
- int signum = parse_and_eval_address (signum_exp);
- if (signum < 0
- || signum >= (int)TARGET_SIGNAL_LAST
- || signum == (int)TARGET_SIGNAL_UNKNOWN
- || signum == (int)TARGET_SIGNAL_DEFAULT)
- error ("Invalid signal number %d.", signum);
- oursig = signum;
+ /* No, try numeric. */
+ int num = parse_and_eval_address (signum_exp);
+
+ if (num == 0)
+ oursig = TARGET_SIGNAL_0;
+ else
+ oursig = target_signal_from_command (num);
}
if (from_tty)
}
clear_proceed_status ();
- proceed (stop_pc, oursig, 0);
+ /* "signal 0" should not get stuck if we are stopped at a breakpoint.
+ FIXME: Neither should "signal foo" but when I tried passing
+ (CORE_ADDR)-1 unconditionally I got a testsuite failure which I haven't
+ tried to track down yet. */
+ proceed (oursig == TARGET_SIGNAL_0 ? (CORE_ADDR) -1 : stop_pc, oursig, 0);
}
/* Call breakpoint_auto_delete on the current contents of the bpstat
pointed to by arg (which is really a bpstat *). */
-void
+
+static void
breakpoint_auto_delete_contents (arg)
PTR arg;
{
breakpoint_auto_delete (*(bpstat *)arg);
}
+
/* Execute a "stack dummy", a piece of code stored in the stack
by the debugger to be executed in the inferior.
int
run_stack_dummy (addr, buffer)
CORE_ADDR addr;
- char buffer[REGISTER_BYTES];
+ char *buffer;
{
struct cleanup *old_cleanups = make_cleanup (null_cleanup, 0);
POP_FRAME;
return(0);
}
-#ifdef CALL_DUMMY_BREAKPOINT_OFFSET
- {
- struct breakpoint *bpt;
- struct symtab_and_line sal;
-
-#if CALL_DUMMY_LOCATION != AT_ENTRY_POINT
- sal.pc = addr - CALL_DUMMY_START_OFFSET + CALL_DUMMY_BREAKPOINT_OFFSET;
-#else
- sal.pc = CALL_DUMMY_ADDRESS ();
-#endif
- sal.symtab = NULL;
- sal.line = 0;
-
- /* Set up a FRAME for the dummy frame so we can pass it to
- set_momentary_breakpoint. We need to give the breakpoint a
- frame in case there is only one copy of the dummy (e.g.
- CALL_DUMMY_LOCATION == AFTER_TEXT_END). */
- flush_cached_frames ();
-
- /* If defined, CALL_DUMMY_BREAKPOINT_OFFSET is where we need to put
- a breakpoint instruction. If not, the call dummy already has the
- breakpoint instruction in it.
-
- addr is the address of the call dummy plus the CALL_DUMMY_START_OFFSET,
- so we need to subtract the CALL_DUMMY_START_OFFSET. */
- bpt = set_momentary_breakpoint (sal,
- get_current_frame (),
- bp_call_dummy);
- bpt->disposition = delete;
-
- /* If all error()s out of proceed ended up calling normal_stop (and
- perhaps they should; it already does in the special case of error
- out of resume()), then we wouldn't need this. */
- make_cleanup (breakpoint_auto_delete_contents, &stop_bpstat);
- }
-#endif /* CALL_DUMMY_BREAKPOINT_OFFSET. */
+ if (CALL_DUMMY_BREAKPOINT_OFFSET_P)
+ {
+ struct breakpoint *bpt;
+ struct symtab_and_line sal;
+
+ INIT_SAL (&sal); /* initialize to zeroes */
+ if (CALL_DUMMY_LOCATION == AT_ENTRY_POINT)
+ {
+ sal.pc = CALL_DUMMY_ADDRESS ();
+ }
+ else
+ {
+ sal.pc = addr - CALL_DUMMY_START_OFFSET + CALL_DUMMY_BREAKPOINT_OFFSET;
+ }
+ sal.section = find_pc_overlay (sal.pc);
+
+ /* Set up a FRAME for the dummy frame so we can pass it to
+ set_momentary_breakpoint. We need to give the breakpoint a
+ frame in case there is only one copy of the dummy (e.g.
+ CALL_DUMMY_LOCATION == AFTER_TEXT_END). */
+ flush_cached_frames ();
+ set_current_frame (create_new_frame (read_fp (), sal.pc));
+
+ /* If defined, CALL_DUMMY_BREAKPOINT_OFFSET is where we need to put
+ a breakpoint instruction. If not, the call dummy already has the
+ breakpoint instruction in it.
+
+ addr is the address of the call dummy plus the CALL_DUMMY_START_OFFSET,
+ so we need to subtract the CALL_DUMMY_START_OFFSET. */
+ bpt = set_momentary_breakpoint (sal,
+ get_current_frame (),
+ bp_call_dummy);
+ bpt->disposition = del;
+
+ /* If all error()s out of proceed ended up calling normal_stop (and
+ perhaps they should; it already does in the special case of error
+ out of resume()), then we wouldn't need this. */
+ make_cleanup (breakpoint_auto_delete_contents, &stop_bpstat);
+ }
+ disable_watchpoints_before_interactive_call_start ();
proceed_to_finish = 1; /* We want stop_registers, please... */
proceed (addr, TARGET_SIGNAL_0, 0);
+ enable_watchpoints_after_interactive_call_stop ();
discard_cleanups (old_cleanups);
/* On return, the stack dummy has been popped already. */
- memcpy (buffer, stop_registers, sizeof stop_registers);
+ memcpy (buffer, stop_registers, REGISTER_BYTES);
return 0;
}
\f
until_next_command (from_tty)
int from_tty;
{
- FRAME frame;
+ struct frame_info *frame;
CORE_ADDR pc;
struct symbol *func;
struct symtab_and_line sal;
int from_tty;
{
struct symtab_and_line sal;
- register FRAME frame;
- struct frame_info *fi;
+ register struct frame_info *frame;
register struct symbol *function;
struct breakpoint *breakpoint;
struct cleanup *old_chain;
clear_proceed_status ();
- fi = get_frame_info (frame);
- sal = find_pc_line (fi->pc, 0);
- sal.pc = fi->pc;
+ sal = find_pc_line (frame->pc, 0);
+ sal.pc = frame->pc;
breakpoint = set_momentary_breakpoint (sal, frame, bp_finish);
- old_chain = make_cleanup(delete_breakpoint, breakpoint);
+ old_chain = make_cleanup ((make_cleanup_func) delete_breakpoint, breakpoint);
/* Find the function we will return from. */
- fi = get_frame_info (selected_frame);
- function = find_pc_function (fi->pc);
+ function = find_pc_function (selected_frame->pc);
/* Print info on the selected frame, including level number
but not source. */
struct type *value_type;
register value_ptr val;
CORE_ADDR funcaddr;
+ int struct_return;
value_type = TYPE_TARGET_TYPE (SYMBOL_TYPE (function));
if (!value_type)
funcaddr = BLOCK_START (SYMBOL_BLOCK_VALUE (function));
- val = value_being_returned (value_type, stop_registers,
- using_struct_return (value_of_variable (function, NULL),
- funcaddr,
- value_type,
- BLOCK_GCC_COMPILED (SYMBOL_BLOCK_VALUE (function))));
+ struct_return = using_struct_return (value_of_variable (function, NULL),
- printf_filtered ("Value returned is $%d = ", record_latest_value (val));
- value_print (val, gdb_stdout, 0, Val_no_prettyprint);
- printf_filtered ("\n");
+ funcaddr,
+ check_typedef (value_type),
+ BLOCK_GCC_COMPILED (SYMBOL_BLOCK_VALUE (function)));
+
+ if (!struct_return)
+ {
+ val = value_being_returned (value_type, stop_registers, struct_return);
+ printf_filtered ("Value returned is $%d = ", record_latest_value (val));
+ value_print (val, gdb_stdout, 0, Val_no_prettyprint);
+ printf_filtered ("\n");
+ }
+ else
+ {
+ /* elz: we cannot determine the contents of the structure because
+ it is on the stack, and we don't know where, since we did not
+ initiate the call, as opposed to the call_function_by_hand case */
+#ifdef VALUE_RETURNED_FROM_STACK
+ val = 0;
+ printf_filtered ("Value returned has type: %s.",
+ TYPE_NAME (value_type));
+ printf_filtered (" Cannot determine contents\n");
+#else
+ val = value_being_returned (value_type, stop_registers,
+ struct_return);
+ printf_filtered ("Value returned is $%d = ",
+ record_latest_value (val));
+ value_print (val, gdb_stdout, 0, Val_no_prettyprint);
+ printf_filtered ("\n");
+#endif
+
+ }
}
do_cleanups(old_chain);
}
while (num != 0)
{
if (num < 0)
- printf_filtered ("It stopped at a breakpoint that has since been deleted.\n");
+ {
+ printf_filtered ("It stopped at a breakpoint that has ");
+ printf_filtered ("since been deleted.\n");
+ }
else
printf_filtered ("It stopped at breakpoint %d.\n", num);
num = bpstat_num (&bs);
}
if (!from_tty)
- printf_filtered ("Type \"info stack\" or \"info registers\" for more information.\n");
+ {
+ printf_filtered ("Type \"info stack\" or \"info registers\" ");
+ printf_filtered ("for more information.\n");
+ }
}
\f
static void
var = savestring (arg, p - arg);
if (nullset)
{
- printf_filtered ("Setting environment variable \"%s\" to null value.\n", var);
+ printf_filtered ("Setting environment variable ");
+ printf_filtered ("\"%s\" to null value.\n", var);
set_in_environ (inferior_environ, var, "");
}
else
int from_tty;
{
char *exec_path;
-
+ char *env;
dont_repeat ();
- exec_path = strsave (get_in_environ (inferior_environ, path_var_name));
+ env = get_in_environ (inferior_environ, path_var_name);
+ /* Can be null if path is not set */
+ if (!env)
+ env = "";
+ exec_path = strsave (env);
mod_path (dirname, &exec_path);
set_in_environ (inferior_environ, path_var_name, exec_path);
free (exec_path);
if (from_tty)
path_info ((char *)NULL, from_tty);
}
-\f
-const char * const reg_names[] = REGISTER_NAMES;
+\f
+#ifdef REGISTER_NAMES
+char *gdb_register_names[] = REGISTER_NAMES;
+#endif
/* Print out the machine register regnum. If regnum is -1,
print all registers (fpregs == 1) or all non-float registers
(fpregs == 0).
continue;
}
- fputs_filtered (reg_names[i], gdb_stdout);
- print_spaces_filtered (15 - strlen (reg_names[i]), gdb_stdout);
+ /* If the register name is empty, it is undefined for this
+ processor, so don't display anything. */
+ if (REGISTER_NAME (i) == NULL || *(REGISTER_NAME (i)) == '\0')
+ continue;
+
+ fputs_filtered (REGISTER_NAME (i), gdb_stdout);
+ print_spaces_filtered (15 - strlen (REGISTER_NAME (i)), gdb_stdout);
/* Get the data in raw format. */
if (read_relative_register_raw_bytes (i, raw_buffer))
{
- printf_filtered ("Invalid register contents\n");
+ printf_filtered ("*value not available*\n");
continue;
}
printf_filtered ("<invalid float>");
else
#endif
- val_print (REGISTER_VIRTUAL_TYPE (i), virtual_buffer, 0,
+ val_print (REGISTER_VIRTUAL_TYPE (i), virtual_buffer, 0, 0,
gdb_stdout, 0, 1, 0, Val_pretty_default);
printf_filtered ("\t(raw 0x");
for (j = 0; j < REGISTER_RAW_SIZE (i); j++)
- printf_filtered ("%02x", (unsigned char)raw_buffer[j]);
+ {
+ register int idx = TARGET_BYTE_ORDER == BIG_ENDIAN ? j
+ : REGISTER_RAW_SIZE (i) - 1 - j;
+ printf_filtered ("%02x", (unsigned char)raw_buffer[idx]);
+ }
printf_filtered (")");
}
/* Else if virtual format is too long for printf,
print in hex a byte at a time. */
- else if (REGISTER_VIRTUAL_SIZE (i) > sizeof (long))
+ else if (REGISTER_VIRTUAL_SIZE (i) > (int) sizeof (long))
{
register int j;
printf_filtered ("0x");
/* Else print as integer in hex and in decimal. */
else
{
- val_print (REGISTER_VIRTUAL_TYPE (i), raw_buffer, 0,
+ val_print (REGISTER_VIRTUAL_TYPE (i), virtual_buffer, 0, 0,
gdb_stdout, 'x', 1, 0, Val_pretty_default);
printf_filtered ("\t");
- val_print (REGISTER_VIRTUAL_TYPE (i), raw_buffer, 0,
+ val_print (REGISTER_VIRTUAL_TYPE (i), virtual_buffer, 0, 0,
gdb_stdout, 0, 1, 0, Val_pretty_default);
}
}
#endif /* no DO_REGISTERS_INFO. */
-static void
+extern int target_map_name_to_register PARAMS ((char *, int));
+
+void
registers_info (addr_exp, fpregs)
char *addr_exp;
int fpregs;
if (!target_has_registers)
error ("The program has no registers now.");
+ if (selected_frame == NULL)
+ error ("No selected frame.");
if (!addr_exp)
{
while (*end != '\0' && *end != ' ' && *end != '\t')
++end;
numregs = ARCH_NUM_REGS;
- for (regnum = 0; regnum < numregs; regnum++)
- if (!strncmp (addr_exp, reg_names[regnum], end - addr_exp)
- && strlen (reg_names[regnum]) == end - addr_exp)
- goto found;
+
+ regnum = target_map_name_to_register (addr_exp, end - addr_exp);
+ if (regnum >= 0)
+ goto found;
+
+ regnum = numregs;
+
if (*addr_exp >= '0' && *addr_exp <= '9')
regnum = atoi (addr_exp); /* Take a number */
if (regnum >= numregs) /* Bad name, or bad number */
} while (*addr_exp != '\0');
}
-static void
+void
all_registers_info (addr_exp, from_tty)
char *addr_exp;
int from_tty;
registers_info (addr_exp, 1);
}
-static void
+void
nofp_registers_info (addr_exp, from_tty)
char *addr_exp;
int from_tty;
{
registers_info (addr_exp, 0);
}
+
\f
/*
* TODO:
char *args;
int from_tty;
{
+#ifdef SOLIB_ADD
+ extern int auto_solib_add;
+#endif
+
+ char * exec_file;
+ char * full_exec_path = NULL;
+
dont_repeat (); /* Not for the faint of heart */
if (target_has_execution)
clear_proceed_status ();
stop_soon_quietly = 1;
-#ifndef MACH
- /* Mach 3 does not generate any traps when attaching to inferior,
- and to set up frames we can do this. */
-
+ /* No traps are generated when attaching to inferior under Mach 3
+ or GNU hurd. */
+#ifndef ATTACH_NO_WAIT
wait_for_inferior ();
#endif
+ /*
+ * If no exec file is yet known, try to determine it from the
+ * process itself.
+ */
+ exec_file = (char *) get_exec_file (0);
+ if (! exec_file) {
+ exec_file = target_pid_to_exec_file (inferior_pid);
+ if (exec_file) {
+ /* It's possible we don't have a full path, but rather just a
+ filename. Some targets, such as HP-UX, don't provide the
+ full path, sigh.
+
+ Attempt to qualify the filename against the source path.
+ (If that fails, we'll just fall back on the original
+ filename. Not much more we can do...)
+ */
+ if (!source_full_path_of (exec_file, &full_exec_path))
+ full_exec_path = savestring (exec_file, strlen (exec_file));
+
+ exec_file_attach (full_exec_path, from_tty);
+ symbol_file_command (full_exec_path, from_tty);
+ }
+ }
+
#ifdef SOLIB_ADD
- /* Add shared library symbols from the newly attached process, if any. */
- SOLIB_ADD ((char *)0, from_tty, (struct target_ops *)0);
+ if (auto_solib_add)
+ {
+ /* Add shared library symbols from the newly attached process, if any. */
+ SOLIB_ADD ((char *)0, from_tty, ¤t_target);
+ re_enable_breakpoints_in_shlibs ();
+ }
#endif
+ /* Take any necessary post-attaching actions for this platform.
+ */
+ target_post_attach (inferior_pid);
+
normal_stop ();
}
{
dont_repeat (); /* Not for the faint of heart */
target_detach (args, from_tty);
+#if defined(SOLIB_RESTART)
+ SOLIB_RESTART ();
+#endif
}
/* ARGSUSED */
int from_tty;
{
#ifdef FLOAT_INFO
- FLOAT_INFO;
+ FLOAT_INFO;
#else
- printf_filtered ("No floating point info available for this processor.\n");
+ printf_filtered ("No floating point info available for this processor.\n");
#endif
}
\f
char *args;
int from_tty;
{
- printf_filtered ("\"unset\" must be followed by the name of an unset subcommand.\n");
+ printf_filtered ("\"unset\" must be followed by the name of ");
+ printf_filtered ("an unset subcommand.\n");
help_list (unsetlist, "unset ", -1, gdb_stdout);
}
"Set terminal for future runs of program being debugged.");
add_show_from_set
- (add_set_cmd ("args", class_run, var_string_noescape, (char *)&inferior_args,
-
-"Set arguments to give program being debugged when it is started.\n\
+ (add_set_cmd ("args", class_run, var_string_noescape,
+ (char *)&inferior_args,
+"Set argument list to give program being debugged when it is started.\n\
Follow this command with any number of args, to be passed to the program.",
&setlist),
&showlist);
$cwd in the path means the current working directory.\n\
This path is equivalent to the $PATH shell variable. It is a list of\n\
directories, separated by colons. These directories are searched to find\n\
-fully linked executable files and separately compiled object files as needed.", &showlist);
+fully linked executable files and separately compiled object files as needed.",
+ &showlist);
c->completer = noop_completer;
add_com ("attach", class_run, attach_command,
"Attach to a process or file outside of GDB.\n\
This command attaches to another target, of the same type as your last\n\
-`target' command (`info files' will show your target stack).\n\
+\"target\" command (\"info files\" will show your target stack).\n\
The command may take as argument a process id or a device file.\n\
For a process id, you must have permission to send the process a signal,\n\
and it must have the same effective uid as the debugger.\n\
-When using \"attach\", you should use the \"file\" command to specify\n\
-the program running in the process, and to load its symbol table.");
+When using \"attach\" with a process id, the debugger finds the\n\
+program running in the process, looking first in the current working\n\
+directory, or (if not found there) using the source file search path\n\
+(see the \"directory\" command). You can also use the \"file\" command\n\
+to specify the program, and to load its symbol table.");
add_com ("detach", class_run, detach_command,
"Detach a process or file previously attached.\n\
-If a process, it is no longer traced, and it continues its execution. If you\n\
-were debugging a file, the file is closed and gdb no longer accesses it.");
+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.");
add_com ("signal", class_run, signal_command,
- "Continue program giving it signal number SIGNUMBER.");
+ "Continue program giving it signal specified by the argument.\n\
+An argument of \"0\" means continue program without giving it a signal.");
add_com ("stepi", class_run, stepi_command,
"Step one instruction exactly.\n\
when they do, the call is treated as one instruction.\n\
Argument N means do this N times (or till program stops for another reason).");
add_com_alias ("n", "next", class_run, 1);
+ if (xdb_commands)
+ add_com_alias("S", "next", class_run, 1);
add_com ("step", class_run, step_command,
"Step program until it reaches a different source line.\n\
add_com_alias ("s", "step", class_run, 1);
add_com ("until", class_run, until_command,
- "Execute until the program reaches a source line greater than the current\n\
+"Execute until the program reaches a source line greater than the current\n\
or a specified line or address or function (same args as break command).\n\
Execution will also stop upon exit from the current stack frame.");
add_com_alias ("u", "until", class_run, 1);
Give as argument either LINENUM or *ADDR, where ADDR is an expression\n\
for an address to start at.");
+ if (xdb_commands)
+ add_com ("go", class_run, go_command,
+ "Usage: go <location>\n\
+Continue program being debugged, stopping at specified line or \n\
+address.\n\
+Give as argument either LINENUM or *ADDR, where ADDR is an \n\
+expression for an address to start at.\n\
+This command is a combination of tbreak and jump.");
+
+ if (xdb_commands)
+ add_com_alias("g", "go", class_run, 1);
+
add_com ("continue", class_run, continue_command,
"Continue program being debugged, after signal or breakpoint.\n\
If proceeding from breakpoint, a number N may be used as an argument,\n\
To cancel previous arguments and run with no arguments,\n\
use \"set args\" without arguments.");
add_com_alias ("r", "run", class_run, 1);
+ if (xdb_commands)
+ add_com ("R", class_run, run_no_args_command,
+ "Start debugged program with no arguments.");
add_info ("registers", nofp_registers_info,
"List of integer registers and their contents, for selected stack frame.\n\
Register name as argument means describe only that register.");
+ if (xdb_commands)
+ add_com("lr", class_info, nofp_registers_info,
+ "List of integer registers and their contents, for selected stack frame.\n\
+ Register name as argument means describe only that register.");
add_info ("all-registers", all_registers_info,
-"List of all registers and their contents, for selected stack frame.\n\
+ "List of all registers and their contents, for selected stack frame.\n\
Register name as argument means describe only that register.");
add_info ("program", program_info,
projects / deliverable / binutils-gdb.git / blobdiff