{
struct minimal_symbol *msymbol;
+ /* FIXME: This should be using containing_function_bounds or a
+ cleaned-up version thereof, to deal with things like the
+ end of the text segment. */
+
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.");
+ if (msymbol == NULL || SYMBOL_NAME (msymbol + 1) == NULL)
+ {
+ /* If sigtramp is in the u area, check for it. */
+#if defined SIGTRAMP_START
+ if (IN_SIGTRAMP (stop_pc, (char *)NULL))
+ {
+ step_range_start = SIGTRAMP_START;
+ step_range_end = SIGTRAMP_END;
+ }
+ else
+#endif
+ error ("Cannot find bounds of current function.");
+ }
+ else
+ {
+ step_range_start = SYMBOL_VALUE_ADDRESS (msymbol);
+ step_range_end = SYMBOL_VALUE_ADDRESS (msymbol + 1);
+ }
printf_filtered ("Single stepping until function exit.\n");
fflush (stdout);
-
- step_range_start = msymbol -> address;
- step_range_end = (msymbol + 1) -> address;
}
}
else
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);
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. */
+ signum = strtosigno (signum_exp);
+
+ if (signum == 0)
+ /* Not found as a name, try it as an expression. */
+ signum = parse_and_eval_address (signum_exp);
if (from_tty)
- printf_filtered ("Continuing with signal %d.\n", signum);
+ {
+ char *signame = strsigno (signum);
+ printf_filtered ("Continuing with signal ");
+ if (signame == NULL || signum == 0)
+ printf_filtered ("%d.\n", signum);
+ else
+ /* Do we need to print the number as well as the name? */
+ printf_filtered ("%s (%d).\n", signame, signum);
+ }
clear_proceed_status ();
proceed (stop_pc, signum, 0);
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. */
+ Otherwise, the caller never gets returned to.
+
+ NAME is a string to print to identify the function which we are calling.
+ It is not guaranteed to be the name of a function, it could be something
+ like "at 0x4370" if a name can't be found for the function. */
/* DEBUG HOOK: 4 => return instead of letting the stack dummy run. */
static int stack_dummy_testing = 0;
void
-run_stack_dummy (addr, buffer)
+run_stack_dummy (name, addr, buffer)
+ char *name;
CORE_ADDR addr;
char buffer[REGISTER_BYTES];
{
if (!stop_stack_dummy)
/* This used to say
- "Cannot continue previously requested operation". */
+ "The expression which contained the function call has been discarded."
+ It is a hard concept to explain in a few words. Ideally, GDB would
+ be able to resume evaluation of the expression when the function
+ finally is done executing. Perhaps someday this will be implemented
+ (it would not be easy). */
error ("\
The program being debugged stopped while in a function called from GDB.\n\
-The expression which contained the function call has been discarded.");
+When the function (%s) is done executing, GDB will silently\n\
+stop (instead of continuing to evaluate the expression containing\n\
+the function call).", name);
/* On return, the stack dummy has been popped already. */
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
num = bpstat_num (&bs);
}
}
- else if (stop_signal) {
+ else if (stop_signal)
+ {
#ifdef PRINT_RANDOM_SIGNAL
- PRINT_RANDOM_SIGNAL (stop_signal);
+ PRINT_RANDOM_SIGNAL (stop_signal);
#else
- printf_filtered ("It stopped with signal %d (%s).\n",
- stop_signal, safe_strsignal (stop_signal));
+ char *signame = strsigno (stop_signal);
+ printf_filtered ("It stopped with signal ");
+ if (signame == NULL)
+ printf_filtered ("%d", stop_signal);
+ else
+ /* Do we need to print the number as well as the name? */
+ printf_filtered ("%s (%d)", signame, stop_signal);
+ printf_filtered (", %s.\n", safe_strsignal (stop_signal));
#endif
}
{
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. */
-
- if (val < p)
+ /* 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)
/* Handle the execution path (PATH variable) */
-const static char path_var_name[] = "PATH";
+static const char path_var_name[] = "PATH";
/* ARGSUSED */
static void
path_info ((char *)NULL, from_tty);
}
\f
+/* This routine is getting awfully cluttered with #if's. It's probably
+ time to turn this into READ_PC and define it in the tm.h file.
+ Ditto for write_pc. */
+
CORE_ADDR
read_pc ()
{
+#ifdef GDB_TARGET_IS_HPPA
+ int flags = read_register(FLAGS_REGNUM);
+
+ if (flags & 2)
+ return read_register(31) & ~0x3; /* User PC is here when in sys call */
+ return read_register (PC_REGNUM) & ~0x3;
+#else
+#ifdef TARGET_READ_PC
+ return TARGET_READ_PC ();
+#else
return ADDR_BITS_REMOVE ((CORE_ADDR) read_register (PC_REGNUM));
+#endif
+#endif
}
void
write_pc (val)
CORE_ADDR val;
{
+#ifdef TARGET_WRITE_PC
+ TARGET_WRITE_PC (val);
+#else
write_register (PC_REGNUM, (long) val);
#ifdef NPC_REGNUM
- write_register (NPC_REGNUM, (long) val+4);
+ write_register (NPC_REGNUM, (long) val + 4);
+#ifdef NNPC_REGNUM
+ write_register (NNPC_REGNUM, (long) val + 8);
+#endif
+#endif
#endif
pc_changed = 0;
}
+/* Cope with strage ways of getting to the stack and frame pointers */
+
+CORE_ADDR
+read_sp ()
+{
+#ifdef TARGET_READ_SP
+ return TARGET_READ_SP ();
+#else
+ return read_register (SP_REGNUM);
+#endif
+}
+
+void
+write_sp (val)
+ CORE_ADDR val;
+{
+#ifdef TARGET_WRITE_SP
+ TARGET_WRITE_SP (val);
+#else
+ write_register (SP_REGNUM, val);
+#endif
+}
+
+
+CORE_ADDR
+read_fp ()
+{
+#ifdef TARGET_READ_FP
+ return TARGET_READ_FP ();
+#else
+ return read_register (FP_REGNUM);
+#endif
+}
+
+void
+write_fp (val)
+ CORE_ADDR val;
+{
+#ifdef TARGET_WRITE_FP
+ TARGET_WRITE_FP (val);
+#else
+ write_register (FP_REGNUM, val);
+#endif
+}
+
const char * const reg_names[] = REGISTER_NAMES;
/* Print out the machine register regnum. If regnum is -1,
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);
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