#include "gdbcmd.h"
#include "gdbcore.h"
#include "target.h"
+#include "language.h"
static void
continue_command PARAMS ((char *, int));
/* 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;
FRAME_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. */
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;
puts_filtered(" ");
puts_filtered(inferior_args);
puts_filtered("\n");
- fflush (stdout);
+ 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. */
if (!fr) /* Avoid coredump here. Why tho? */
error ("No current frame");
step_frame_address = FRAME_FP (fr);
+ 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
}
struct symtab_and_line sal;
struct symbol *fn;
struct symbol *sfn;
- char *fname;
- struct cleanup *back_to;
ERROR_NO_INFERIOR;
sfn = find_pc_function (sal.pc);
if (fn != NULL && sfn != fn)
{
- fname = strdup_demangled (SYMBOL_NAME (fn));
- back_to = make_cleanup (free, fname);
- if (!query ("Line %d is not in `%s'. Jump anyway? ", sal.line, fname))
+ if (!query ("Line %d is not in `%s'. Jump anyway? ", sal.line,
+ SYMBOL_SOURCE_NAME (fn)))
{
error ("Not confirmed.");
/* NOTREACHED */
}
- do_cleanups (back_to);
}
- 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)
+ {
+ /* 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;
+ }
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);
+ proceed (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 ();
+
+ /* 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. */
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
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
}
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");
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;
-}
-
const char * const reg_names[] = REGISTER_NAMES;
/* Print out the machine register regnum. If regnum is -1,
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;
}
-
- REGISTER_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)
end = addr_exp;
while (*end != '\0' && *end != ' ' && *end != '\t')
++end;
- for (regnum = 0; regnum < NUM_REGS; regnum++)
+ 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 >= NUM_REGS) /* Bad name, or bad number */
+ if (regnum >= numregs) /* Bad name, or bad number */
error ("%.*s: invalid register", end - addr_exp, addr_exp);
found:
if (query ("A program is being debugged already. Kill it? "))
target_kill ();
else
- error ("Inferior not killed.");
+ error ("Not killed.");
}
target_attach (args, from_tty);
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. */
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
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);
projects / deliverable / binutils-gdb.git / blobdiff