-/* Memory-access and commands for "inferior" (child) process, for GDB.
+/* Memory-access and commands for "inferior" process, for GDB.
Copyright 1986, 1987, 1988, 1989, 1991, 1992 Free Software Foundation, Inc.
This file is part of GDB.
#include "gdbcmd.h"
#include "gdbcore.h"
#include "target.h"
+#include "language.h"
-static void
-continue_command PARAMS ((char *, int));
+static void continue_command PARAMS ((char *, int));
-static void
-until_next_command PARAMS ((int));
+static void until_next_command PARAMS ((int));
-static void
-until_command PARAMS ((char *, int));
+static void until_command PARAMS ((char *, int));
-static void
-path_info PARAMS ((char *, int));
+static void path_info PARAMS ((char *, int));
-static void
-path_command PARAMS ((char *, int));
+static void path_command PARAMS ((char *, int));
-static void
-unset_command PARAMS ((char *, int));
+static void unset_command PARAMS ((char *, int));
-static void
-float_info PARAMS ((char *, int));
+static void float_info PARAMS ((char *, int));
-static void
-detach_command PARAMS ((char *, int));
+static void detach_command PARAMS ((char *, int));
-static void
-nofp_registers_info PARAMS ((char *, int));
+static void nofp_registers_info PARAMS ((char *, int));
-static void
-all_registers_info PARAMS ((char *, int));
+static void all_registers_info PARAMS ((char *, int));
-static void
-registers_info PARAMS ((char *, int));
+static void registers_info PARAMS ((char *, int));
-static void
-do_registers_info PARAMS ((int, int));
+static void do_registers_info PARAMS ((int, int));
-static void
-unset_environment_command PARAMS ((char *, int));
+static void unset_environment_command PARAMS ((char *, int));
-static void
-set_environment_command PARAMS ((char *, int));
+static void set_environment_command PARAMS ((char *, int));
-static void
-environment_info PARAMS ((char *, int));
+static void environment_info PARAMS ((char *, int));
-static void
-program_info PARAMS ((char *, int));
+static void program_info PARAMS ((char *, int));
-static void
-finish_command PARAMS ((char *, int));
+static void finish_command PARAMS ((char *, int));
-static void
-signal_command PARAMS ((char *, int));
+static void signal_command PARAMS ((char *, int));
-static void
-jump_command PARAMS ((char *, int));
+static void jump_command PARAMS ((char *, int));
-static void
-step_1 PARAMS ((int, int, char *));
+static void step_1 PARAMS ((int, int, char *));
-static void
-nexti_command PARAMS ((char *, int));
+static void nexti_command PARAMS ((char *, int));
-static void
-stepi_command PARAMS ((char *, int));
+static void stepi_command PARAMS ((char *, int));
-static void
-next_command PARAMS ((char *, int));
+static void next_command PARAMS ((char *, int));
-static void
-step_command PARAMS ((char *, int));
+static void step_command PARAMS ((char *, int));
-static void
-run_command PARAMS ((char *, int));
+static void run_command PARAMS ((char *, int));
#define ERROR_NO_INFERIOR \
if (!target_has_execution) error ("The program is not being run.");
/* Last signal that the inferior received (why it stopped). */
-int stop_signal;
+enum target_signal stop_signal;
/* Address at which inferior stopped. */
CORE_ADDR stop_pc;
-/* Stack frame when program stopped. */
-
-FRAME_ADDR stop_frame_address;
-
/* Chain containing status of breakpoint(s) that we have stopped at. */
bpstat stop_bpstat;
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. */
+
+CORE_ADDR step_sp;
/* 1 means step over all subroutine calls.
+ 0 means don't step over calls (used by stepi).
-1 means step over calls to undebuggable functions. */
int step_over_calls;
target_kill ();
}
+ clear_breakpoint_hit_counts ();
+
exec_file = (char *) get_exec_file (0);
/* 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 ();
+ /* We keep symbols from add-symbol-file, on the grounds that the
+ user might want to add some symbols before running the program
+ (right?). But sometimes (dynamic loading where the user manually
+ introduces the new symbols with add-symbol-file), the code which
+ the symbols describe does not persist between runs. Currently
+ the user has to manually nuke all symbols between runs if they
+ want them to go away (PR 2207). This is probably reasonable. */
+
if (args)
{
char *cmd;
if (from_tty)
{
- printf_filtered ("Starting program: %s %s\n",
- exec_file? exec_file: "", inferior_args);
- fflush (stdout);
+ puts_filtered("Starting program: ");
+ if (exec_file)
+ puts_filtered(exec_file);
+ puts_filtered(" ");
+ puts_filtered(inferior_args);
+ puts_filtered("\n");
+ gdb_flush (gdb_stdout);
}
target_create_inferior (exec_file, inferior_args,
clear_proceed_status ();
- proceed ((CORE_ADDR) -1, -1, 0);
+ proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 0);
}
\f
/* Step until outside of current statement. */
char *count_string;
{
register int count = 1;
- FRAME fr;
+ struct frame_info *frame;
struct cleanup *cleanups = 0;
ERROR_NO_INFERIOR;
{
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)
{
find_pc_line_pc_range (stop_pc, &step_range_start, &step_range_end);
if (step_range_end == 0)
{
- struct minimal_symbol *msymbol;
+ char *name;
+ if (find_pc_partial_function (stop_pc, &name, &step_range_start,
+ &step_range_end) == 0)
+ error ("Cannot find bounds of current function");
- msymbol = lookup_minimal_symbol_by_pc (stop_pc);
target_terminal_ours ();
- printf_filtered ("Current function has no line number information.\n");
- fflush (stdout);
-
- /* No info or after _etext ("Can't happen") */
- if (msymbol == NULL || (msymbol + 1) -> name == NULL)
- error ("No data available on pc function.");
-
- printf_filtered ("Single stepping until function exit.\n");
- fflush (stdout);
-
- step_range_start = msymbol -> address;
- step_range_end = (msymbol + 1) -> address;
+ printf_filtered ("\
+Single stepping until exit from function %s, \n\
+which has no line number information.\n", name);
+ gdb_flush (gdb_stdout);
}
}
else
{
- /* Say we are stepping, but stop after one insn whatever it does.
- Don't step through subroutine calls even to undebuggable
- functions. */
+ /* Say we are stepping, but stop after one insn whatever it does. */
step_range_start = step_range_end = 1;
if (!skip_subroutines)
+ /* It is stepi.
+ Don't step over function calls, not even to functions lacking
+ line numbers. */
step_over_calls = 0;
}
step_over_calls = 1;
step_multi = (count > 1);
- proceed ((CORE_ADDR) -1, -1, 1);
+ proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 1);
if (! stop_step)
break;
+
+ /* FIXME: On nexti, this may have already been done (when we hit the
+ step resume break, I think). Probably this should be moved to
+ wait_for_inferior (near the top). */
#if defined (SHIFT_INST_REGS)
- write_register (NNPC_REGNUM, read_register (NPC_REGNUM));
- write_register (NPC_REGNUM, read_register (PC_REGNUM));
+ SHIFT_INST_REGS();
#endif
}
register CORE_ADDR addr;
struct symtabs_and_lines sals;
struct symtab_and_line sal;
+ struct symbol *fn;
+ struct symbol *sfn;
ERROR_NO_INFERIOR;
resolve_sal_pc (&sal); /* May error out */
- {
- struct symbol *fn = get_frame_function (get_current_frame ());
- struct symbol *sfn = find_pc_function (sal.pc);
- if (fn != 0 && sfn != fn
- && ! query ("Line %d is not in `%s'. Jump anyway? ",
- sal.line, SYMBOL_NAME (fn)))
- error ("Not confirmed.");
- }
+ /* See if we are trying to jump to another function. */
+ fn = get_frame_function (get_current_frame ());
+ sfn = find_pc_function (sal.pc);
+ if (fn != NULL && sfn != fn)
+ {
+ if (!query ("Line %d is not in `%s'. Jump anyway? ", sal.line,
+ SYMBOL_SOURCE_NAME (fn)))
+ {
+ error ("Not confirmed.");
+ /* NOTREACHED */
+ }
+ }
- addr = ADDR_BITS_SET (sal.pc);
+ addr = sal.pc;
if (from_tty)
- printf_filtered ("Continuing at %s.\n", local_hex_string(addr));
+ {
+ printf_filtered ("Continuing at ");
+ print_address_numeric (addr, 1, gdb_stdout);
+ printf_filtered (".\n");
+ }
clear_proceed_status ();
- proceed (addr, 0, 0);
+ proceed (addr, TARGET_SIGNAL_0, 0);
}
/* Continue program giving it specified signal. */
char *signum_exp;
int from_tty;
{
- register int signum;
+ enum target_signal oursig;
dont_repeat (); /* Too dangerous. */
ERROR_NO_INFERIOR;
if (!signum_exp)
error_no_arg ("signal number");
- signum = parse_and_eval_address (signum_exp);
+ /* It would be even slicker to make signal names be valid expressions,
+ (the type could be "enum $signal" or some such), then the user could
+ assign them to convenience variables. */
+ oursig = target_signal_from_name (signum_exp);
+
+ if (oursig == TARGET_SIGNAL_UNKNOWN)
+ {
+ /* 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)
- printf_filtered ("Continuing with signal %d.\n", signum);
+ {
+ if (oursig == TARGET_SIGNAL_0)
+ printf_filtered ("Continuing with no signal.\n");
+ else
+ printf_filtered ("Continuing with signal %s.\n",
+ target_signal_to_name (oursig));
+ }
clear_proceed_status ();
- proceed (stop_pc, signum, 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
+breakpoint_auto_delete_contents (arg)
+ PTR arg;
+{
+ breakpoint_auto_delete (*(bpstat *)arg);
}
/* Execute a "stack dummy", a piece of code stored in the stack
The dummy's frame is automatically popped whenever that break is hit.
If that is the first time the program stops, run_stack_dummy
- returns to its caller with that frame already gone.
- Otherwise, the caller never gets returned to. */
+ returns to its caller with that frame already gone and returns 0.
+ Otherwise, run_stack-dummy returns 1 (the frame will eventually be popped
+ when we do hit that breakpoint). */
/* DEBUG HOOK: 4 => return instead of letting the stack dummy run. */
static int stack_dummy_testing = 0;
-void
+int
run_stack_dummy (addr, buffer)
CORE_ADDR addr;
char buffer[REGISTER_BYTES];
{
+ struct cleanup *old_cleanups = make_cleanup (null_cleanup, 0);
+
/* Now proceed, having reached the desired place. */
clear_proceed_status ();
if (stack_dummy_testing & 4)
{
POP_FRAME;
- return;
+ 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 ();
+ 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 = 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. */
+
proceed_to_finish = 1; /* We want stop_registers, please... */
- proceed (addr, 0, 0);
+ proceed (addr, TARGET_SIGNAL_0, 0);
+
+ discard_cleanups (old_cleanups);
if (!stop_stack_dummy)
- /* This used to say
- "Cannot continue previously requested operation". */
- error ("\
-The program being debugged stopped while in a function called from GDB.\n\
-The expression which contained the function call has been discarded.");
+ return 1;
/* On return, the stack dummy has been popped already. */
- bcopy (stop_registers, buffer, sizeof stop_registers);
+ memcpy (buffer, stop_registers, sizeof stop_registers);
+ return 0;
}
\f
/* Proceed until we reach a different source line with pc greater than
Note that eventually this command should probably be changed so
that only source lines are printed out when we hit the breakpoint
- we set. I'm going to postpone this until after a hopeful rewrite
- of wait_for_inferior and the proceed status code. -- randy */
+ we set. This may involve changes to wait_for_inferior and the
+ proceed status code. */
/* ARGSUSED */
static void
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;
if (msymbol == NULL)
error ("Execution is not within a known function.");
- step_range_start = msymbol -> address;
+ step_range_start = SYMBOL_VALUE_ADDRESS (msymbol);
step_range_end = pc;
}
else
step_over_calls = 1;
step_frame_address = FRAME_FP (frame);
-
+ step_sp = read_sp ();
+
step_multi = 0; /* Only one call to proceed */
- proceed ((CORE_ADDR) -1, -1, 1);
+ proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 1);
}
static void
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);
/* 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. */
}
proceed_to_finish = 1; /* We want stop_registers, please... */
- proceed ((CORE_ADDR) -1, -1, 0);
+ proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 0);
/* Did we stop at our breakpoint? */
if (bpstat_find_breakpoint(stop_bpstat, breakpoint) != NULL
&& function != 0)
{
struct type *value_type;
- register value val;
+ register value_ptr val;
CORE_ADDR funcaddr;
value_type = TYPE_TARGET_TYPE (SYMBOL_TYPE (function));
funcaddr = BLOCK_START (SYMBOL_BLOCK_VALUE (function));
val = value_being_returned (value_type, stop_registers,
- using_struct_return (value_of_variable (function),
+ using_struct_return (value_of_variable (function, NULL),
funcaddr,
value_type,
BLOCK_GCC_COMPILED (SYMBOL_BLOCK_VALUE (function))));
printf_filtered ("Value returned is $%d = ", record_latest_value (val));
- value_print (val, stdout, 0, Val_no_prettyprint);
+ value_print (val, gdb_stdout, 0, Val_no_prettyprint);
printf_filtered ("\n");
}
do_cleanups(old_chain);
}
target_files_info ();
- printf_filtered ("Program stopped at %s.\n", local_hex_string(stop_pc));
+ printf_filtered ("Program stopped at %s.\n",
+ local_hex_string((unsigned long) stop_pc));
if (stop_step)
printf_filtered ("It stopped after being stepped.\n");
else if (num != 0)
num = bpstat_num (&bs);
}
}
- else if (stop_signal) {
-#ifdef PRINT_RANDOM_SIGNAL
- PRINT_RANDOM_SIGNAL (stop_signal);
-#else
- printf_filtered ("It stopped with signal %d (%s).\n",
- stop_signal, safe_strsignal (stop_signal));
-#endif
- }
+ else if (stop_signal != TARGET_SIGNAL_0)
+ {
+ printf_filtered ("It stopped with signal %s, %s.\n",
+ target_signal_to_name (stop_signal),
+ target_signal_to_string (stop_signal));
+ }
if (!from_tty)
printf_filtered ("Type \"info stack\" or \"info registers\" for more information.\n");
{
register char *val = get_in_environ (inferior_environ, var);
if (val)
- printf_filtered ("%s = %s\n", var, val);
+ {
+ puts_filtered (var);
+ puts_filtered (" = ");
+ puts_filtered (val);
+ puts_filtered ("\n");
+ }
else
- printf_filtered ("Environment variable \"%s\" not defined.\n", var);
+ {
+ puts_filtered ("Environment variable \"");
+ puts_filtered (var);
+ puts_filtered ("\" not defined.\n");
+ }
}
else
{
register char **vector = environ_vector (inferior_environ);
while (*vector)
- printf_filtered ("%s\n", *vector++);
+ {
+ puts_filtered (*vector++);
+ puts_filtered ("\n");
+ }
}
}
if (p != 0 && val != 0)
{
/* We have both a space and an equals. If the space is before the
- equals and the only thing between the two is more space, use
- the equals */
+ equals, walk forward over the spaces til we see a nonspace
+ (possibly the equals). */
if (p > val)
while (*val == ' ')
val++;
- /* Take the smaller of the two. If there was space before the
- "=", they will be the same right now. */
- p = arg + min (p - arg, val - arg);
+ /* Now if the = is after the char following the spaces,
+ take the char following the spaces. */
+ if (p > val)
+ p = val - 1;
}
else if (val != 0 && p == 0)
p = val;
/* Handle the execution path (PATH variable) */
-const static char path_var_name[] = "PATH";
+static const char path_var_name[] = "PATH";
/* ARGSUSED */
static void
char *args;
int from_tty;
{
- printf_filtered ("Executable and object file path: %s\n",
- get_in_environ (inferior_environ, path_var_name));
+ puts_filtered ("Executable and object file path: ");
+ puts_filtered (get_in_environ (inferior_environ, path_var_name));
+ puts_filtered ("\n");
}
/* Add zero or more directories to the front of the execution path. */
path_info ((char *)NULL, from_tty);
}
\f
-CORE_ADDR
-read_pc ()
-{
- return ADDR_BITS_REMOVE ((CORE_ADDR) read_register (PC_REGNUM));
-}
-
-void
-write_pc (val)
- CORE_ADDR val;
-{
- write_register (PC_REGNUM, (long) val);
-#ifdef NPC_REGNUM
- write_register (NPC_REGNUM, (long) val+4);
-#endif
- pc_changed = 0;
-}
+/* The array of register names. */
-const char * const reg_names[] = REGISTER_NAMES;
+char *reg_names[] = REGISTER_NAMES;
/* Print out the machine register regnum. If regnum is -1,
print all registers (fpregs == 1) or all non-float registers
to provide that format. */
#if !defined (DO_REGISTERS_INFO)
+
#define DO_REGISTERS_INFO(regnum, fp) do_registers_info(regnum, fp)
+
static void
do_registers_info (regnum, fpregs)
int regnum;
int fpregs;
{
register int i;
+ int numregs = ARCH_NUM_REGS;
- for (i = 0; i < NUM_REGS; i++)
+ for (i = 0; i < numregs; i++)
{
char raw_buffer[MAX_REGISTER_RAW_SIZE];
char virtual_buffer[MAX_REGISTER_VIRTUAL_SIZE];
continue;
}
- fputs_filtered (reg_names[i], stdout);
- print_spaces_filtered (15 - strlen (reg_names[i]), stdout);
+ fputs_filtered (reg_names[i], gdb_stdout);
+ print_spaces_filtered (15 - strlen (reg_names[i]), gdb_stdout);
- /* Get the data in raw format, then convert also to virtual format. */
+ /* Get the data in raw format. */
if (read_relative_register_raw_bytes (i, raw_buffer))
{
printf_filtered ("Invalid register contents\n");
continue;
}
-
- target_convert_to_virtual (i, raw_buffer, virtual_buffer);
+
+ /* Convert raw data to virtual format if necessary. */
+#ifdef REGISTER_CONVERTIBLE
+ if (REGISTER_CONVERTIBLE (i))
+ {
+ REGISTER_CONVERT_TO_VIRTUAL (i, REGISTER_VIRTUAL_TYPE (i),
+ raw_buffer, virtual_buffer);
+ }
+ else
+#endif
+ memcpy (virtual_buffer, raw_buffer,
+ REGISTER_VIRTUAL_SIZE (i));
/* If virtual format is floating, print it that way, and in raw hex. */
- if (TYPE_CODE (REGISTER_VIRTUAL_TYPE (i)) == TYPE_CODE_FLT
- && ! INVALID_FLOAT (virtual_buffer, REGISTER_VIRTUAL_SIZE (i)))
+ if (TYPE_CODE (REGISTER_VIRTUAL_TYPE (i)) == TYPE_CODE_FLT)
{
register int j;
- val_print (REGISTER_VIRTUAL_TYPE (i), virtual_buffer, 0,
- stdout, 0, 1, 0, Val_pretty_default);
+#ifdef INVALID_FLOAT
+ if (INVALID_FLOAT (virtual_buffer, REGISTER_VIRTUAL_SIZE (i)))
+ printf_filtered ("<invalid float>");
+ else
+#endif
+ val_print (REGISTER_VIRTUAL_TYPE (i), virtual_buffer, 0,
+ gdb_stdout, 0, 1, 0, Val_pretty_default);
printf_filtered ("\t(raw 0x");
for (j = 0; j < REGISTER_RAW_SIZE (i); j++)
else
{
val_print (REGISTER_VIRTUAL_TYPE (i), raw_buffer, 0,
- stdout, 'x', 1, 0, Val_pretty_default);
+ gdb_stdout, 'x', 1, 0, Val_pretty_default);
printf_filtered ("\t");
val_print (REGISTER_VIRTUAL_TYPE (i), raw_buffer, 0,
- stdout, 0, 1, 0, Val_pretty_default);
+ gdb_stdout, 0, 1, 0, Val_pretty_default);
}
/* The SPARC wants to print even-numbered float regs as doubles
char *addr_exp;
int fpregs;
{
- int regnum;
+ int regnum, numregs;
+ register char *end;
if (!target_has_registers)
error ("The program has no registers now.");
- if (addr_exp)
+ if (!addr_exp)
{
- if (*addr_exp >= '0' && *addr_exp <= '9')
- regnum = atoi (addr_exp);
- else
- {
- register char *p = addr_exp;
- if (p[0] == '$')
- p++;
- for (regnum = 0; regnum < NUM_REGS; regnum++)
- if (!strcmp (p, reg_names[regnum]))
- break;
- if (regnum == NUM_REGS)
- error ("%s: invalid register name.", addr_exp);
- }
+ DO_REGISTERS_INFO(-1, fpregs);
+ return;
}
- else
- regnum = -1;
- DO_REGISTERS_INFO(regnum, fpregs);
+ do
+ {
+ if (addr_exp[0] == '$')
+ addr_exp++;
+ end = 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;
+ if (*addr_exp >= '0' && *addr_exp <= '9')
+ regnum = atoi (addr_exp); /* Take a number */
+ if (regnum >= numregs) /* Bad name, or bad number */
+ error ("%.*s: invalid register", end - addr_exp, addr_exp);
+
+found:
+ DO_REGISTERS_INFO(regnum, fpregs);
+
+ addr_exp = end;
+ while (*addr_exp == ' ' || *addr_exp == '\t')
+ ++addr_exp;
+ } while (*addr_exp != '\0');
}
static void
*/
/*
- * attach_command --
- * takes a program started up outside of gdb and ``attaches'' to it.
- * This stops it cold in its tracks and allows us to start tracing it.
- * For this to work, we must be able to send the process a
- * signal and we must have the same effective uid as the program.
- */
+ attach_command --
+ 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.
+ and wait for the trace-trap that results from attaching. */
+
void
attach_command (args, from_tty)
char *args;
int from_tty;
{
dont_repeat (); /* Not for the faint of heart */
+
+ if (target_has_execution)
+ {
+ if (query ("A program is being debugged already. Kill it? "))
+ target_kill ();
+ else
+ error ("Not killed.");
+ }
+
target_attach (args, from_tty);
+
+ /* Set up the "saved terminal modes" of the inferior
+ based on what modes we are starting it with. */
+ target_terminal_init ();
+
+ /* Install inferior's terminal modes. */
+ target_terminal_inferior ();
+
+ /* 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 ();
+ 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. */
+
+ wait_for_inferior ();
+#endif
+
+#ifdef SOLIB_ADD
+ /* Add shared library symbols from the newly attached process, if any. */
+ SOLIB_ADD ((char *)0, from_tty, (struct target_ops *)0);
+#endif
+
+ normal_stop ();
}
/*
#endif
}
\f
-struct cmd_list_element *unsetlist = NULL;
-
/* ARGSUSED */
static void
unset_command (args, from_tty)
int from_tty;
{
printf_filtered ("\"unset\" must be followed by the name of an unset subcommand.\n");
- help_list (unsetlist, "unset ", -1, stdout);
+ help_list (unsetlist, "unset ", -1, gdb_stdout);
}
void
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\
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\
-then the same breakpoint won't break until the Nth time it is reached.");
+If proceeding from breakpoint, a number N may be used as an argument,\n\
+which means to set the ignore count of that breakpoint to N - 1 (so that\n\
+the breakpoint won't break until the Nth time it is reached).");
add_com_alias ("c", "cont", class_run, 1);
add_com_alias ("fg", "cont", class_run, 1);
"Start debugged program. You may specify arguments to give it.\n\
Args may include \"*\", or \"[...]\"; they are expanded using \"sh\".\n\
Input and output redirection with \">\", \"<\", or \">>\" are also allowed.\n\n\
-With no arguments, uses arguments last specified (with \"run\" or \"set args\".\n\
+With no arguments, uses arguments last specified (with \"run\" or \"set args\").\n\
To cancel previous arguments and run with no arguments,\n\
use \"set args\" without arguments.");
add_com_alias ("r", "run", class_run, 1);