Toolchain/binutils-gdb
1
0
Fork 0
forked from Imagelibrary/binutils-gdb
Code Pull Requests Activity

gdb-3.1

Browse Source
This commit is contained in:
gdb-3.1
1989-01-31 17:56:40 +00:00
committed by Pedro Alves
parent bb7592f010
commit e91b87a368
150 changed files with 54576 additions and 10225 deletions
Download Patch File Download Diff File Expand all files Collapse all files

268
gdb/infcmd.c
View File

@@ -19,9 +19,8 @@ anyone else from sharing it farther. Help stamp out software hoarding!
*/
#include "defs.h"
#include "initialize.h"
#include "symtab.h"
#include "param.h"
#include "symtab.h"
#include "frame.h"
#include "inferior.h"
#include "environ.h"
@@ -59,7 +58,7 @@ CORE_ADDR stop_pc;
/* Stack frame when program stopped. */
FRAME stop_frame;
FRAME_ADDR stop_frame_address;
/* Number of breakpoint it stopped at, or 0 if none. */
@@ -73,6 +72,11 @@ int stop_step;
int stop_stack_dummy;
/* Nonzero if stopped due to a random (unexpected) signal in inferior
process. */
int stopped_by_random_signal;
/* Range to single step within.
If this is nonzero, respond to a single-step signal
by continuing to step if the pc is in this range. */
@@ -84,7 +88,7 @@ CORE_ADDR step_range_end; /* Exclusive */
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. */
CORE_ADDR step_frame;
FRAME_ADDR step_frame_address;
/* 1 means step over all subroutine calls.
-1 means step over calls to undebuggable functions. */
@@ -105,7 +109,6 @@ struct environ *inferior_environ;
CORE_ADDR read_pc ();
struct command_line *get_breakpoint_commands ();
START_FILE
int
have_inferior_p ()
@@ -150,11 +153,11 @@ run_command (args, from_tty)
if (inferior_pid)
{
if (query ("The program being debugged has been started already.\n\
if (
!query ("The program being debugged has been started already.\n\
Start it from the beginning? "))
kill_inferior ();
else
error ("Program already started.");
error ("Program not restarted.");
kill_inferior ();
}
if (remote_debugging)
@@ -200,7 +203,7 @@ cont_command (proc_count_exp, from_tty)
/* If have argument, set proceed count of breakpoint we stopped at. */
if (stop_breakpoint && proc_count_exp)
if (stop_breakpoint > 0 && proc_count_exp)
{
set_ignore_count (stop_breakpoint,
parse_and_eval_address (proc_count_exp) - 1,
@@ -261,21 +264,36 @@ step_1 (skip_subroutines, single_inst, count_string)
{
clear_proceed_status ();
step_frame = get_current_frame ();
step_frame_address = FRAME_FP (get_current_frame ());
if (! single_inst)
{
find_pc_line_pc_range (stop_pc, &step_range_start, &step_range_end);
if (step_range_end == 0)
{
int misc;
misc = find_pc_misc_function (stop_pc);
terminal_ours ();
error ("Current function has no line number information.");
printf ("Current function has no line number information.\n");
fflush (stdout);
/* No info or after _etext ("Can't happen") */
if (misc == -1 || misc == misc_function_count - 1)
error ("No data available on pc function.");
printf ("Single stepping until function exit.\n");
fflush (stdout);
step_range_start = misc_function_vector[misc].address;
step_range_end = misc_function_vector[misc + 1].address;
}
}
else
{
/* Say we are stepping, but stop after one insn whatever it does.
Don't step through subroutine calls even to undebuggable functions. */
Don't step through subroutine calls even to undebuggable
functions. */
step_range_start = step_range_end = 1;
if (!skip_subroutines)
step_over_calls = 0;
@@ -307,7 +325,7 @@ jump_command (arg, from_tty)
if (!arg)
error_no_arg ("starting address");
sals = decode_line_spec (arg, 1);
sals = decode_line_spec_1 (arg, 1);
if (sals.nelts != 1)
{
error ("Unreasonable jump request");
@@ -393,20 +411,6 @@ run_stack_dummy (addr, buffer)
CORE_ADDR addr;
REGISTER_TYPE *buffer;
{
int saved_pc_changed = pc_changed;
int saved_stop_signal = stop_signal;
int saved_stop_pc = stop_pc;
int saved_stop_frame = stop_frame;
int saved_stop_breakpoint = stop_breakpoint;
int saved_stop_step = stop_step;
int saved_stop_stack_dummy = stop_stack_dummy;
FRAME saved_selected_frame;
int saved_selected_level;
struct command_line *saved_breakpoint_commands
= get_breakpoint_commands ();
record_selected_frame (&saved_selected_frame, &saved_selected_level);
/* Now proceed, having reached the desired place. */
clear_proceed_status ();
if (stack_dummy_testing & 4)
@@ -419,21 +423,86 @@ run_stack_dummy (addr, buffer)
if (!stop_stack_dummy)
error ("Cannot continue previously requested operation.");
set_breakpoint_commands (saved_breakpoint_commands);
select_frame (saved_selected_frame, saved_selected_level);
stop_signal = saved_stop_signal;
stop_pc = saved_stop_pc;
stop_frame = saved_stop_frame;
stop_breakpoint = saved_stop_breakpoint;
stop_step = saved_stop_step;
stop_stack_dummy = saved_stop_stack_dummy;
pc_changed = saved_pc_changed;
/* On return, the stack dummy has been popped already. */
bcopy (stop_registers, buffer, sizeof stop_registers);
}
/* Proceed until we reach the given line as argument or exit the
function. When called with no argument, proceed until we reach a
different source line with pc greater than our current one or exit
the function. We skip calls in both cases.
The effect of this command with an argument is identical to setting
a momentary breakpoint at the line specified and executing
"finish".
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 */
void
until_next_command (arg, from_tty)
char *arg;
int from_tty;
{
FRAME frame;
CORE_ADDR pc;
struct symbol *func;
struct symtab_and_line sal;
clear_proceed_status ();
frame = get_current_frame ();
/* Step until either exited from this function or greater
than the current line (if in symbolic section) or pc (if
not). */
pc = read_pc ();
func = find_pc_function (pc);
if (!func)
{
int misc_func = find_pc_misc_function (pc);
if (misc_func != -1)
error ("Execution is not within a known function.");
step_range_start = misc_function_vector[misc_func].address;
step_range_end = pc;
}
else
{
sal = find_pc_line (pc, 0);
step_range_start = BLOCK_START (SYMBOL_BLOCK_VALUE (func));
step_range_end = sal.end;
}
step_over_calls = 1;
step_frame_address = FRAME_FP (frame);
step_multi = 0; /* Only one call to proceed */
proceed (-1, -1, 1);
}
void
until_command (arg, from_tty)
char *arg;
int from_tty;
{
if (!have_inferior_p ())
error ("The program is not being run.");
if (arg)
until_break_command (arg, from_tty);
else
until_next_command (arg, from_tty);
}
/* "finish": Set a temporary breakpoint at the place
the selected frame will return to, then continue. */
@@ -444,8 +513,7 @@ finish_command (arg, from_tty)
{
struct symtab_and_line sal;
register FRAME frame;
struct frame_info fi;
struct frame_info *fi;
register struct symbol *function;
if (!have_inferior_p ())
@@ -460,14 +528,14 @@ finish_command (arg, from_tty)
clear_proceed_status ();
fi = get_frame_info (frame);
sal = find_pc_line (fi.pc, 0);
sal.pc = fi.pc;
sal = find_pc_line (fi->pc, 0);
sal.pc = fi->pc;
set_momentary_breakpoint (sal, frame);
/* Find the function we will return from. */
fi = get_frame_info (fi.next_frame, fi.next_next_frame);
function = find_pc_function (fi.pc);
fi = get_frame_info (selected_frame);
function = find_pc_function (fi->pc);
if (from_tty)
{
@@ -481,12 +549,22 @@ finish_command (arg, from_tty)
{
struct type *value_type;
register value val;
CORE_ADDR funcaddr;
value_type = TYPE_TARGET_TYPE (SYMBOL_TYPE (function));
if (!value_type)
fatal ("internal: finish_command: function has no target type");
if (TYPE_CODE (value_type) == TYPE_CODE_VOID)
return;
val = value_being_returned (value_type, stop_registers);
funcaddr = BLOCK_START (SYMBOL_BLOCK_VALUE (function));
val = value_being_returned (value_type, stop_registers,
using_struct_return (function,
funcaddr,
value_type));
printf ("Value returned is $%d = ", record_latest_value (val));
value_print (val, stdout, 0);
putchar ('\n');
@@ -506,7 +584,7 @@ program_info ()
inferior_pid, stop_pc);
if (stop_step)
printf ("It stopped after being stepped.\n");
else if (stop_breakpoint)
else if (stop_breakpoint > 0)
printf ("It stopped at breakpoint %d.\n", stop_breakpoint);
else if (stop_signal)
printf ("It stopped with signal %d (%s).\n",
@@ -540,30 +618,58 @@ set_environment_command (arg)
char *arg;
{
register char *p, *val, *var;
int nullset = 0;
if (arg == 0)
error_no_arg ("environment variable and value");
/* Find seperation between variable name and value */
p = (char *) index (arg, '=');
val = (char *) index (arg, ' ');
if (p != 0 && val != 0)
p = arg + min (p - arg, val - arg);
{
/* 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 */
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);
}
else if (val != 0 && p == 0)
p = val;
if (p == 0)
error ("Space or \"=\" must separate variable name and its value");
if (p[1] == 0)
error_no_arg ("value for the variable");
if (p == arg)
error_no_arg ("environment variable to set");
val = p + 1;
while (*val == ' ' || *val == '\t') val++;
if (p == 0 || p[1] == 0)
{
nullset = 1;
if (p == 0)
p = arg + strlen (arg); /* So that savestring below will work */
}
else
{
/* Not setting variable value to null */
val = p + 1;
while (*val == ' ' || *val == '\t')
val++;
}
while (p != arg && (p[-1] == ' ' || p[-1] == '\t')) p--;
var = savestring (arg, p - arg);
set_in_environ (inferior_environ, var, val);
if (nullset)
{
printf ("Setting environment variable \"%s\" to null value.\n", var);
set_in_environ (inferior_environ, var, "");
}
else
set_in_environ (inferior_environ, var, val);
free (var);
}
@@ -579,6 +685,7 @@ unset_environment_command (var)
/* Read an integer from debugged memory, given address and number of bytes. */
long
read_memory_integer (memaddr, len)
CORE_ADDR memaddr;
int len;
@@ -617,6 +724,7 @@ read_pc ()
return (CORE_ADDR) read_register (PC_REGNUM);
}
void
write_pc (val)
CORE_ADDR val;
{
@@ -635,6 +743,9 @@ registers_info (addr_exp)
register int i;
int regnum;
if (!have_inferior_p () && !have_core_file_p ())
error ("No inferior or core file");
if (addr_exp)
{
if (*addr_exp >= '0' && *addr_exp <= '9')
@@ -669,7 +780,7 @@ registers_info (addr_exp)
{
printf ("--Type Return to print more--");
fflush (stdout);
read_line ();
gdb_read_line (0, 0);
}
/* Get the data in raw format, then convert also to virtual format. */
@@ -681,7 +792,8 @@ registers_info (addr_exp)
/* If virtual format is floating, print it that way. */
if (TYPE_CODE (REGISTER_VIRTUAL_TYPE (i)) == TYPE_CODE_FLT
&& ! INVALID_FLOAT (virtual_buffer, REGISTER_VIRTUAL_SIZE (i)))
val_print (REGISTER_VIRTUAL_TYPE (i), virtual_buffer, 0, stdout, 0, 1);
val_print (REGISTER_VIRTUAL_TYPE (i), virtual_buffer, 0,
stdout, 0, 1);
/* 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))
@@ -824,16 +936,31 @@ detach_command (args, from_tty)
inferior_pid = 0;
}
#endif /* ATTACH_DETACH */
/* ARGUSUED */
static void
float_info (addr_exp)
char *addr_exp;
{
#ifdef FLOAT_INFO
FLOAT_INFO;
#else
printf ("No floating point info available for this processor.\n");
#endif
}
static
initialize ()
extern struct cmd_list_element *setlist, *deletelist;
void
_initialize_infcmd ()
{
add_com ("tty", class_run, tty_command,
"Set terminal for future runs of program being debugged.");
add_com ("set-args", class_run, set_args_command,
add_cmd ("args", class_run, set_args_command,
"Specify arguments to give program being debugged when it is started.\n\
Follow this command with any number of args, to be passed to the program.");
Follow this command with any number of args, to be passed to the program.",
&setlist);
add_info ("environment", environment_info,
"The environment to give the program, or one variable's value.\n\
@@ -841,14 +968,17 @@ With an argument VAR, prints the value of environment variable VAR to\n\
give the program being debugged. With no arguments, prints the entire\n\
environment to be given to the program.");
add_com ("unset-environment", class_run, unset_environment_command,
add_cmd ("environment", class_run, unset_environment_command,
"Cancel environment variable VAR for the program.\n\
This does not affect the program until the next \"run\" command.");
add_com ("set-environment", class_run, set_environment_command,
This does not affect the program until the next \"run\" command.",
&deletelist);
add_cmd ("environment", class_run, set_environment_command,
"Set environment variable value to give the program.\n\
Arguments are VAR VALUE where VAR is variable name and VALUE is value.\n\
VALUES of environment variables are uninterpreted strings.\n\
This does not affect the program until the next \"run\" command.");
This does not affect the program until the next \"run\" command.",
&setlist);
#ifdef ATTACH_DETACH
add_com ("attach", class_run, attach_command,
@@ -892,6 +1022,12 @@ Argument N means do this N times (or till program stops for another reason).");
Argument N means do this N times (or till program stops for another reason).");
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\
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);
add_com ("jump", class_run, jump_command,
"Continue program being debugged at specified line or address.\n\
Give as argument either LINENUM or *ADDR, where ADDR is an expression\n\
@@ -919,9 +1055,11 @@ Register name as argument means describe only that register.");
add_info ("program", program_info,
"Execution status of the program.");
add_info ("float", float_info,
"Print the status of the floating point unit\n");
inferior_args = savestring (" ", 1); /* By default, no args. */
inferior_environ = make_environ ();
init_environ (inferior_environ);
}
END_FILE