/* Memory-access and commands for "inferior" process, for GDB.
- Copyright 1986, 87, 88, 89, 91, 92, 95, 96, 1998, 1999
+ Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
+ 1996, 1997, 1998, 1999, 2000, 2001, 2002
Free Software Foundation, Inc.
This file is part of GDB.
#include "environ.h"
#include "value.h"
#include "gdbcmd.h"
+#include "symfile.h"
#include "gdbcore.h"
#include "target.h"
#include "language.h"
#include "symfile.h"
#include "objfiles.h"
+#include "completer.h"
+#include "ui-out.h"
#include "event-top.h"
#include "parser-defs.h"
+#include "regcache.h"
/* Functions exported for general use: */
-void nofp_registers_info PARAMS ((char *, int));
+void nofp_registers_info (char *, int);
-void all_registers_info PARAMS ((char *, int));
+void all_registers_info (char *, int);
-void registers_info PARAMS ((char *, int));
+void registers_info (char *, int);
/* Local functions: */
-void continue_command PARAMS ((char *, int));
+void continue_command (char *, int);
static void print_return_value (int struct_return, struct type *value_type);
-static void finish_command_continuation PARAMS ((struct continuation_arg *));
+static void finish_command_continuation (struct continuation_arg *);
-static void until_next_command PARAMS ((int));
+static void until_next_command (int);
-static void until_command PARAMS ((char *, int));
+static void until_command (char *, int);
-static void path_info PARAMS ((char *, int));
+static void path_info (char *, int);
-static void path_command PARAMS ((char *, int));
+static void path_command (char *, int);
-static void unset_command PARAMS ((char *, int));
+static void unset_command (char *, int);
-static void float_info PARAMS ((char *, int));
+static void float_info (char *, int);
-static void detach_command PARAMS ((char *, int));
+static void detach_command (char *, int);
static void interrupt_target_command (char *args, int from_tty);
-#if !defined (DO_REGISTERS_INFO)
-static void do_registers_info PARAMS ((int, int));
-#endif
-
-static void unset_environment_command PARAMS ((char *, int));
+static void unset_environment_command (char *, int);
-static void set_environment_command PARAMS ((char *, int));
+static void set_environment_command (char *, int);
-static void environment_info PARAMS ((char *, int));
+static void environment_info (char *, int);
-static void program_info PARAMS ((char *, int));
+static void program_info (char *, int);
-static void finish_command PARAMS ((char *, int));
+static void finish_command (char *, int);
-static void signal_command PARAMS ((char *, int));
+static void signal_command (char *, int);
-static void jump_command PARAMS ((char *, int));
+static void jump_command (char *, int);
-static void step_1 PARAMS ((int, int, char *));
+static void step_1 (int, int, char *);
static void step_once (int skip_subroutines, int single_inst, int count);
static void step_1_continuation (struct continuation_arg *arg);
-void nexti_command PARAMS ((char *, int));
+void nexti_command (char *, int);
-void stepi_command PARAMS ((char *, int));
+void stepi_command (char *, int);
-static void next_command PARAMS ((char *, int));
+static void next_command (char *, int);
-static void step_command PARAMS ((char *, int));
+static void step_command (char *, int);
-static void run_command PARAMS ((char *, int));
+static void run_command (char *, int);
-static void run_no_args_command PARAMS ((char *args, int from_tty));
+static void run_no_args_command (char *args, int from_tty);
-static void go_command PARAMS ((char *line_no, int from_tty));
+static void go_command (char *line_no, int from_tty);
-static int strip_bg_char PARAMS ((char **));
+static int strip_bg_char (char **);
-void _initialize_infcmd PARAMS ((void));
+void _initialize_infcmd (void);
#define GO_USAGE "Usage: go <location>\n"
-static void breakpoint_auto_delete_contents PARAMS ((PTR));
+static void breakpoint_auto_delete_contents (PTR);
#define ERROR_NO_INFERIOR \
if (!target_has_execution) error ("The program is not being run.");
static char *inferior_args;
+/* The inferior arguments as a vector. If INFERIOR_ARGC is nonzero,
+ then we must compute INFERIOR_ARGS from this (via the target). */
+
+static int inferior_argc;
+static char **inferior_argv;
+
/* File name for default use for standard in/out in the inferior. */
char *inferior_io_terminal;
being debugged it should be nonzero (currently 3 is used) for remote
debugging. */
-int inferior_pid;
+ptid_t inferior_ptid;
/* Last signal that the inferior received (why it stopped). */
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;
+enum step_over_calls_kind step_over_calls;
/* If stepping, nonzero means step count is > 1
so don't print frame next time inferior stops
struct environ *inferior_environ;
\f
+/* Accessor routines. */
+
+char *
+get_inferior_args (void)
+{
+ if (inferior_argc != 0)
+ {
+ char *n, *old;
+
+ n = gdbarch_construct_inferior_arguments (current_gdbarch,
+ inferior_argc, inferior_argv);
+ old = set_inferior_args (n);
+ xfree (old);
+ }
+
+ if (inferior_args == NULL)
+ inferior_args = xstrdup ("");
+
+ return inferior_args;
+}
+
+char *
+set_inferior_args (char *newargs)
+{
+ char *saved_args = inferior_args;
+
+ inferior_args = newargs;
+ inferior_argc = 0;
+ inferior_argv = 0;
+
+ return saved_args;
+}
+
+void
+set_inferior_args_vector (int argc, char **argv)
+{
+ inferior_argc = argc;
+ inferior_argv = argv;
+}
+
+/* Notice when `set args' is run. */
+static void
+notice_args_set (char *args, int from_tty, struct cmd_list_element *c)
+{
+ inferior_argc = 0;
+ inferior_argv = 0;
+}
+
+/* Notice when `show args' is run. */
+static void
+notice_args_read (char *args, int from_tty, struct cmd_list_element *c)
+{
+ /* Might compute the value. */
+ get_inferior_args ();
+}
+
+\f
+/* Compute command-line string given argument vector. This does the
+ same shell processing as fork_inferior. */
+/* ARGSUSED */
+char *
+construct_inferior_arguments (struct gdbarch *gdbarch, int argc, char **argv)
+{
+ char *result;
+
+ if (STARTUP_WITH_SHELL)
+ {
+ /* This holds all the characters considered special to the
+ typical Unix shells. We include `^' because the SunOS
+ /bin/sh treats it as a synonym for `|'. */
+ char *special = "\"!#$&*()\\|[]{}<>?'\"`~^; \t\n";
+ int i;
+ int length = 0;
+ char *out, *cp;
+
+ /* We over-compute the size. It shouldn't matter. */
+ for (i = 0; i < argc; ++i)
+ length += 2 * strlen (argv[i]) + 1;
+
+ result = (char *) xmalloc (length);
+ out = result;
+
+ for (i = 0; i < argc; ++i)
+ {
+ if (i > 0)
+ *out++ = ' ';
+
+ for (cp = argv[i]; *cp; ++cp)
+ {
+ if (strchr (special, *cp) != NULL)
+ *out++ = '\\';
+ *out++ = *cp;
+ }
+ }
+ *out = '\0';
+ }
+ else
+ {
+ /* In this case we can't handle arguments that contain spaces,
+ tabs, or newlines -- see breakup_args(). */
+ int i;
+ int length = 0;
+
+ for (i = 0; i < argc; ++i)
+ {
+ char *cp = strchr (argv[i], ' ');
+ if (cp == NULL)
+ cp = strchr (argv[i], '\t');
+ if (cp == NULL)
+ cp = strchr (argv[i], '\n');
+ if (cp != NULL)
+ error ("can't handle command-line argument containing whitespace");
+ length += strlen (argv[i]) + 1;
+ }
+
+ result = (char *) xmalloc (length);
+ result[0] = '\0';
+ for (i = 0; i < argc; ++i)
+ {
+ if (i > 0)
+ strcat (result, " ");
+ strcat (result, argv[i]);
+ }
+ }
+
+ return result;
+}
+\f
/* This function detects whether or not a '&' character (indicating
background execution) has been added as *the last* of the arguments ARGS
of a command. If it has, it removes it and returns 1. Otherwise it
does nothing and returns 0. */
static int
-strip_bg_char (args)
- char **args;
+strip_bg_char (char **args)
{
char *p = NULL;
/* ARGSUSED */
void
-tty_command (file, from_tty)
- char *file;
- int from_tty;
+tty_command (char *file, int from_tty)
{
if (file == 0)
error_no_arg ("terminal name for running target process");
}
static void
-run_command (args, from_tty)
- char *args;
- int from_tty;
+run_command (char *args, int from_tty)
{
char *exec_file;
dont_repeat ();
- if (inferior_pid != 0 && target_has_execution)
+ if (! ptid_equal (inferior_ptid, null_ptid) && target_has_execution)
{
if (from_tty
&& !query ("The program being debugged has been started already.\n\
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. */
+ /* The comment here used to read, "The exec file is re-read every
+ time we do a generic_mourn_inferior, so we just have to worry
+ about the symbol file." The `generic_mourn_inferior' function
+ gets called whenever the program exits. However, suppose the
+ program exits, and *then* the executable file changes? We need
+ to check again here. Since reopen_exec_file doesn't do anything
+ if the timestamp hasn't changed, I don't see the harm. */
+ reopen_exec_file ();
reread_symbols ();
+ exec_file = (char *) get_exec_file (0);
+
/* 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
}
else
{
- char *cmd;
int async_exec = strip_bg_char (&args);
/* If we get a request for running in the bg but the target
/* If there were other args, beside '&', process them. */
if (args)
{
- cmd = concat ("set args ", args, NULL);
- make_cleanup (free, cmd);
- execute_command (cmd, from_tty);
+ char *old_args = set_inferior_args (xstrdup (args));
+ xfree (old_args);
}
}
if (from_tty)
{
- puts_filtered ("Starting program: ");
+ ui_out_field_string (uiout, NULL, "Starting program");
+ ui_out_text (uiout, ": ");
if (exec_file)
- puts_filtered (exec_file);
- puts_filtered (" ");
- puts_filtered (inferior_args);
- puts_filtered ("\n");
- gdb_flush (gdb_stdout);
+ ui_out_field_string (uiout, "execfile", exec_file);
+ ui_out_spaces (uiout, 1);
+ /* We call get_inferior_args() because we might need to compute
+ the value now. */
+ ui_out_field_string (uiout, "infargs", get_inferior_args ());
+ ui_out_text (uiout, "\n");
+ ui_out_flush (uiout);
}
- target_create_inferior (exec_file, inferior_args,
+ /* We call get_inferior_args() because we might need to compute
+ the value now. */
+ target_create_inferior (exec_file, get_inferior_args (),
environ_vector (inferior_environ));
}
static void
-run_no_args_command (args, from_tty)
- char *args;
- int from_tty;
+run_no_args_command (char *args, int from_tty)
{
- execute_command ("set args", from_tty);
- run_command ((char *) NULL, from_tty);
+ char *old_args = set_inferior_args (xstrdup (""));
+ xfree (old_args);
}
\f
void
-continue_command (proc_count_exp, from_tty)
- char *proc_count_exp;
- int from_tty;
+continue_command (char *proc_count_exp, int from_tty)
{
int async_exec = 0;
ERROR_NO_INFERIOR;
while (num != 0)
{
set_ignore_count (num,
- parse_and_eval_address (proc_count_exp) - 1,
+ parse_and_eval_long (proc_count_exp) - 1,
from_tty);
/* set_ignore_count prints a message ending with a period.
So print two spaces before "Continuing.". */
/* ARGSUSED */
static void
-step_command (count_string, from_tty)
- char *count_string;
- int from_tty;
+step_command (char *count_string, int from_tty)
{
step_1 (0, 0, count_string);
}
/* ARGSUSED */
static void
-next_command (count_string, from_tty)
- char *count_string;
- int from_tty;
+next_command (char *count_string, int from_tty)
{
step_1 (1, 0, count_string);
}
/* ARGSUSED */
void
-stepi_command (count_string, from_tty)
- char *count_string;
- int from_tty;
+stepi_command (char *count_string, int from_tty)
{
step_1 (0, 1, count_string);
}
/* ARGSUSED */
void
-nexti_command (count_string, from_tty)
- char *count_string;
- int from_tty;
+nexti_command (char *count_string, int from_tty)
{
step_1 (1, 1, count_string);
}
static void
-step_1 (skip_subroutines, single_inst, count_string)
- int skip_subroutines;
- int single_inst;
- char *count_string;
+disable_longjmp_breakpoint_cleanup (void *ignore)
+{
+ disable_longjmp_breakpoint ();
+}
+
+static void
+step_1 (int skip_subroutines, int single_inst, char *count_string)
{
register int count = 1;
struct frame_info *frame;
async_disable_stdin ();
}
- count = count_string ? parse_and_eval_address (count_string) : 1;
+ count = count_string ? parse_and_eval_long (count_string) : 1;
if (!single_inst || skip_subroutines) /* leave si command alone */
{
enable_longjmp_breakpoint ();
if (!event_loop_p || !target_can_async_p ())
- cleanups = make_cleanup ((make_cleanup_func) disable_longjmp_breakpoint,
- 0);
+ cleanups = make_cleanup (disable_longjmp_breakpoint_cleanup, 0 /*ignore*/);
else
- make_exec_cleanup ((make_cleanup_func) disable_longjmp_breakpoint, 0);
+ make_exec_cleanup (disable_longjmp_breakpoint_cleanup, 0 /*ignore*/);
}
/* In synchronous case, all is well, just use the regular for loop. */
/* It is stepi.
Don't step over function calls, not even to functions lacking
line numbers. */
- step_over_calls = 0;
+ step_over_calls = STEP_OVER_NONE;
}
if (skip_subroutines)
- step_over_calls = 1;
+ step_over_calls = STEP_OVER_ALL;
step_multi = (count > 1);
proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 1);
proceed(), via step_once(). Basically it is like step_once and
step_1_continuation are co-recursive. */
static void
-step_1_continuation (arg)
- struct continuation_arg *arg;
+step_1_continuation (struct continuation_arg *arg)
{
- int count;
- int skip_subroutines;
- int single_inst;
-
- skip_subroutines = (int) arg->data;
- single_inst = (int) (arg->next)->data;
- count = (int) ((arg->next)->next)->data;
-
- if (stop_step)
- {
- /* 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). */
+ int count;
+ int skip_subroutines;
+ int single_inst;
+
+ skip_subroutines = arg->data.integer;
+ single_inst = arg->next->data.integer;
+ count = arg->next->next->data.integer;
+
+ if (stop_step)
+ {
+ /* 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)
- SHIFT_INST_REGS ();
+ SHIFT_INST_REGS ();
#endif
- step_once (skip_subroutines, single_inst, count - 1);
- }
- else
- if (!single_inst || skip_subroutines)
- do_exec_cleanups (ALL_CLEANUPS);
+ step_once (skip_subroutines, single_inst, count - 1);
+ }
+ else
+ if (!single_inst || skip_subroutines)
+ do_exec_cleanups (ALL_CLEANUPS);
}
/* Do just one step operation. If count >1 we will have to set up a
if (!single_inst)
{
find_pc_line_pc_range (stop_pc, &step_range_start, &step_range_end);
- if (step_range_end == 0)
+
+ /* If we have no line info, switch to stepi mode. */
+ if (step_range_end == 0 && step_stop_if_no_debug)
+ {
+ step_range_start = step_range_end = 1;
+ }
+ else if (step_range_end == 0)
{
char *name;
if (find_pc_partial_function (stop_pc, &name, &step_range_start,
/* It is stepi.
Don't step over function calls, not even to functions lacking
line numbers. */
- step_over_calls = 0;
+ step_over_calls = STEP_OVER_NONE;
}
if (skip_subroutines)
- step_over_calls = 1;
+ step_over_calls = STEP_OVER_ALL;
step_multi = (count > 1);
arg1 =
arg3 =
(struct continuation_arg *) xmalloc (sizeof (struct continuation_arg));
arg1->next = arg2;
- arg1->data = (PTR) skip_subroutines;
+ arg1->data.integer = skip_subroutines;
arg2->next = arg3;
- arg2->data = (PTR) single_inst;
+ arg2->data.integer = single_inst;
arg3->next = NULL;
- arg3->data = (PTR) count;
+ arg3->data.integer = count;
add_intermediate_continuation (step_1_continuation, arg1);
proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 1);
}
/* Continue program at specified address. */
static void
-jump_command (arg, from_tty)
- char *arg;
- int from_tty;
+jump_command (char *arg, int from_tty)
{
register CORE_ADDR addr;
struct symtabs_and_lines sals;
}
sal = sals.sals[0];
- free ((PTR) sals.sals);
+ xfree (sals.sals);
if (sal.symtab == 0 && sal.pc == 0)
error ("No source file has been specified.");
/* Go to line or address in current procedure */
static void
-go_command (line_no, from_tty)
- char *line_no;
- int from_tty;
+go_command (char *line_no, int from_tty)
{
if (line_no == (char *) NULL || !*line_no)
printf_filtered (GO_USAGE);
/* Continue program giving it specified signal. */
static void
-signal_command (signum_exp, from_tty)
- char *signum_exp;
- int from_tty;
+signal_command (char *signum_exp, int from_tty)
{
enum target_signal oursig;
if (oursig == TARGET_SIGNAL_UNKNOWN)
{
/* No, try numeric. */
- int num = parse_and_eval_address (signum_exp);
+ int num = parse_and_eval_long (signum_exp);
if (num == 0)
oursig = TARGET_SIGNAL_0;
pointed to by arg (which is really a bpstat *). */
static void
-breakpoint_auto_delete_contents (arg)
- PTR arg;
+breakpoint_auto_delete_contents (PTR arg)
{
breakpoint_auto_delete (*(bpstat *) arg);
}
will eventually be popped when we do hit the dummy end breakpoint). */
int
-run_stack_dummy (addr, buffer)
- CORE_ADDR addr;
- char *buffer;
+run_stack_dummy (CORE_ADDR addr, struct regcache *buffer)
{
struct cleanup *old_cleanups = make_cleanup (null_cleanup, 0);
int saved_async = 0;
bpt = set_momentary_breakpoint (sal,
get_current_frame (),
bp_call_dummy);
- bpt->disposition = del;
+ bpt->disposition = disp_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
discard_cleanups (old_cleanups);
+ /* We can stop during an inferior call because a signal is received. */
if (stopped_by_random_signal)
- {
- /* If the inferior execution fails we need to restore our
- stack. It is not done by proceed() in this case. */
- /* Pop the empty frame that contains the stack dummy.
- POP_FRAME ends with a setting of the current frame, so we
- can use that next. */
- POP_FRAME;
- return 1;
- }
+ return 1;
/* We may also stop prematurely because we hit a breakpoint in the
- called routine. We do not pop the frame as the user may wish
- to single step or continue from there. */
+ called routine. */
if (!stop_stack_dummy)
return 2;
/* On normal return, the stack dummy has been popped already. */
-
- memcpy (buffer, stop_registers, REGISTER_BYTES);
+ regcache_cpy_no_passthrough (buffer, stop_registers);
return 0;
}
\f
/* ARGSUSED */
static void
-until_next_command (from_tty)
- int from_tty;
+until_next_command (int from_tty)
{
struct frame_info *frame;
CORE_ADDR pc;
step_range_end = sal.end;
}
- step_over_calls = 1;
+ step_over_calls = STEP_OVER_ALL;
step_frame_address = FRAME_FP (frame);
step_sp = read_sp ();
}
static void
-until_command (arg, from_tty)
- char *arg;
- int from_tty;
+until_command (char *arg, int from_tty)
{
int async_exec = 0;
static void
print_return_value (int structure_return, struct type *value_type)
{
- register value_ptr value;
+ struct value *value;
+ static struct ui_stream *stb = NULL;
if (!structure_return)
{
value = value_being_returned (value_type, stop_registers, structure_return);
- printf_filtered ("Value returned is $%d = ", record_latest_value (value));
- value_print (value, gdb_stdout, 0, Val_no_prettyprint);
- printf_filtered ("\n");
+ stb = ui_out_stream_new (uiout);
+ ui_out_text (uiout, "Value returned is ");
+ ui_out_field_fmt (uiout, "gdb-result-var", "$%d", record_latest_value (value));
+ ui_out_text (uiout, " = ");
+ value_print (value, stb->stream, 0, Val_no_prettyprint);
+ ui_out_field_stream (uiout, "return-value", stb);
+ ui_out_text (uiout, "\n");
}
else
{
initiate the call, as opposed to the call_function_by_hand case */
#ifdef VALUE_RETURNED_FROM_STACK
value = 0;
- printf_filtered ("Value returned has type: %s.", TYPE_NAME (value_type));
- printf_filtered (" Cannot determine contents\n");
+ ui_out_text (uiout, "Value returned has type: ");
+ ui_out_field_string (uiout, "return-type", TYPE_NAME (value_type));
+ ui_out_text (uiout, ".");
+ ui_out_text (uiout, " Cannot determine contents\n");
#else
value = value_being_returned (value_type, stop_registers, structure_return);
- printf_filtered ("Value returned is $%d = ", record_latest_value (value));
- value_print (value, gdb_stdout, 0, Val_no_prettyprint);
- printf_filtered ("\n");
+ stb = ui_out_stream_new (uiout);
+ ui_out_text (uiout, "Value returned is ");
+ ui_out_field_fmt (uiout, "gdb-result-var", "$%d", record_latest_value (value));
+ ui_out_text (uiout, " = ");
+ value_print (value, stb->stream, 0, Val_no_prettyprint);
+ ui_out_field_stream (uiout, "return-value", stb);
+ ui_out_text (uiout, "\n");
#endif
}
}
only chance we have to complete this command is in
fetch_inferior_event, which is called by the event loop as soon as it
detects that the target has stopped. This function is called via the
- cmd_continaution pointer. */
+ cmd_continuation pointer. */
void
-finish_command_continuation (arg)
- struct continuation_arg *arg;
+finish_command_continuation (struct continuation_arg *arg)
{
register struct symbol *function;
struct breakpoint *breakpoint;
struct cleanup *cleanups;
- breakpoint = (struct breakpoint *) arg->data;
- function = (struct symbol *) (arg->next)->data;
- cleanups = (struct cleanup *) (arg->next->next)->data;
+ breakpoint = (struct breakpoint *) arg->data.pointer;
+ function = (struct symbol *) arg->next->data.pointer;
+ cleanups = (struct cleanup *) arg->next->next->data.pointer;
if (bpstat_find_breakpoint (stop_bpstat, breakpoint) != NULL
&& function != 0)
value_type = TYPE_TARGET_TYPE (SYMBOL_TYPE (function));
if (!value_type)
- internal_error ("finish_command: function has no target type");
+ internal_error (__FILE__, __LINE__,
+ "finish_command: function has no target type");
if (TYPE_CODE (value_type) == TYPE_CODE_VOID)
{
the selected frame will return to, then continue. */
static void
-finish_command (arg, from_tty)
- char *arg;
- int from_tty;
+finish_command (char *arg, int from_tty)
{
struct symtab_and_line sal;
register struct frame_info *frame;
breakpoint = set_momentary_breakpoint (sal, frame, bp_finish);
if (!event_loop_p || !target_can_async_p ())
- old_chain = make_cleanup ((make_cleanup_func) delete_breakpoint, breakpoint);
+ old_chain = make_cleanup_delete_breakpoint (breakpoint);
else
- old_chain = make_exec_cleanup ((make_cleanup_func) delete_breakpoint, breakpoint);
+ old_chain = make_exec_cleanup_delete_breakpoint (breakpoint);
/* Find the function we will return from. */
if (from_tty)
{
printf_filtered ("Run till exit from ");
- print_stack_frame (selected_frame, selected_frame_level, 0);
+ print_stack_frame (selected_frame,
+ frame_relative_level (selected_frame), 0);
}
/* If running asynchronously and the target support asynchronous
arg1->next = arg2;
arg2->next = arg3;
arg3->next = NULL;
- arg1->data = (PTR) breakpoint;
- arg2->data = (PTR) function;
- arg3->data = (PTR) old_chain;
+ arg1->data.pointer = breakpoint;
+ arg2->data.pointer = function;
+ arg3->data.pointer = old_chain;
add_continuation (finish_command_continuation, arg1);
}
value_type = TYPE_TARGET_TYPE (SYMBOL_TYPE (function));
if (!value_type)
- internal_error ("finish_command: function has no target type");
+ internal_error (__FILE__, __LINE__,
+ "finish_command: function has no target type");
/* FIXME: Shouldn't we do the cleanups before returning? */
if (TYPE_CODE (value_type) == TYPE_CODE_VOID)
\f
/* ARGSUSED */
static void
-program_info (args, from_tty)
- char *args;
- int from_tty;
+program_info (char *args, int from_tty)
{
bpstat bs = stop_bpstat;
int num = bpstat_num (&bs);
}
\f
static void
-environment_info (var, from_tty)
- char *var;
- int from_tty;
+environment_info (char *var, int from_tty)
{
if (var)
{
}
static void
-set_environment_command (arg, from_tty)
- char *arg;
- int from_tty;
+set_environment_command (char *arg, int from_tty)
{
register char *p, *val, *var;
int nullset = 0;
}
else
set_in_environ (inferior_environ, var, val);
- free (var);
+ xfree (var);
}
static void
-unset_environment_command (var, from_tty)
- char *var;
- int from_tty;
+unset_environment_command (char *var, int from_tty)
{
if (var == 0)
{
/* ARGSUSED */
static void
-path_info (args, from_tty)
- char *args;
- int from_tty;
+path_info (char *args, int from_tty)
{
puts_filtered ("Executable and object file path: ");
puts_filtered (get_in_environ (inferior_environ, path_var_name));
/* Add zero or more directories to the front of the execution path. */
static void
-path_command (dirname, from_tty)
- char *dirname;
- int from_tty;
+path_command (char *dirname, int from_tty)
{
char *exec_path;
char *env;
/* Can be null if path is not set */
if (!env)
env = "";
- exec_path = strsave (env);
+ exec_path = xstrdup (env);
mod_path (dirname, &exec_path);
set_in_environ (inferior_environ, path_var_name, exec_path);
- free (exec_path);
+ xfree (exec_path);
if (from_tty)
path_info ((char *) NULL, from_tty);
}
all the registers, define the macro DO_REGISTERS_INFO(regnum, fp)
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;
+void
+do_registers_info (int regnum, int fpregs)
{
register int i;
- int numregs = ARCH_NUM_REGS;
+ int numregs = NUM_REGS + NUM_PSEUDO_REGS;
+ char *raw_buffer = (char*) alloca (MAX_REGISTER_RAW_SIZE);
+ char *virtual_buffer = (char*) alloca (MAX_REGISTER_VIRTUAL_SIZE);
for (i = 0; i < numregs; i++)
{
- char raw_buffer[MAX_REGISTER_RAW_SIZE];
- char virtual_buffer[MAX_REGISTER_VIRTUAL_SIZE];
-
/* Decide between printing all regs, nonfloat regs, or specific reg. */
if (regnum == -1)
{
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))
+ if (! frame_register_read (selected_frame, i, raw_buffer))
{
printf_filtered ("*value not available*\n");
continue;
{
register int j;
-#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, 0,
- gdb_stdout, 0, 1, 0, Val_pretty_default);
+ 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++)
{
- register int idx = TARGET_BYTE_ORDER == BIG_ENDIAN ? j
+ register int idx = TARGET_BYTE_ORDER == BFD_ENDIAN_BIG ? j
: REGISTER_RAW_SIZE (i) - 1 - j;
printf_filtered ("%02x", (unsigned char) raw_buffer[idx]);
}
printf_filtered (")");
}
-
-/* FIXME! val_print probably can handle all of these cases now... */
-
- /* Else if virtual format is too long for printf,
- print in hex a byte at a time. */
- else if (REGISTER_VIRTUAL_SIZE (i) > (int) sizeof (long))
- {
- register int j;
- printf_filtered ("0x");
- for (j = 0; j < REGISTER_VIRTUAL_SIZE (i); j++)
- printf_filtered ("%02x", (unsigned char) virtual_buffer[j]);
- }
/* Else print as integer in hex and in decimal. */
else
{
printf_filtered ("\n");
}
}
-#endif /* no DO_REGISTERS_INFO. */
void
-registers_info (addr_exp, fpregs)
- char *addr_exp;
- int fpregs;
+registers_info (char *addr_exp, int fpregs)
{
int regnum, numregs;
register char *end;
end = addr_exp;
while (*end != '\0' && *end != ' ' && *end != '\t')
++end;
- numregs = ARCH_NUM_REGS;
+ numregs = NUM_REGS + NUM_PSEUDO_REGS;
regnum = target_map_name_to_register (addr_exp, end - addr_exp);
if (regnum >= 0)
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);
+ error ("%.*s: invalid register", (int) (end - addr_exp), addr_exp);
found:
DO_REGISTERS_INFO (regnum, fpregs);
}
void
-all_registers_info (addr_exp, from_tty)
- char *addr_exp;
- int from_tty;
+all_registers_info (char *addr_exp, int from_tty)
{
registers_info (addr_exp, 1);
}
void
-nofp_registers_info (addr_exp, from_tty)
- char *addr_exp;
- int from_tty;
+nofp_registers_info (char *addr_exp, int from_tty)
{
registers_info (addr_exp, 0);
}
and wait for the trace-trap that results from attaching. */
void
-attach_command (args, from_tty)
- char *args;
- int from_tty;
+attach_command (char *args, int from_tty)
{
-#ifdef SOLIB_ADD
- extern int auto_solib_add;
-#endif
-
char *exec_file;
char *full_exec_path = NULL;
wait_for_inferior as soon as the target reports a stop. */
init_wait_for_inferior ();
clear_proceed_status ();
- stop_soon_quietly = 1;
/* No traps are generated when attaching to inferior under Mach 3
or GNU hurd. */
#ifndef ATTACH_NO_WAIT
+ stop_soon_quietly = 1;
wait_for_inferior ();
#endif
exec_file = (char *) get_exec_file (0);
if (!exec_file)
{
- exec_file = target_pid_to_exec_file (inferior_pid);
+ exec_file = target_pid_to_exec_file (PIDGET (inferior_ptid));
if (exec_file)
{
/* It's possible we don't have a full path, but rather just a
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);
+ symbol_file_add_main (full_exec_path, from_tty);
}
}
#ifdef SOLIB_ADD
- 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 ();
- }
+ /* Add shared library symbols from the newly attached process, if any. */
+ SOLIB_ADD ((char *) 0, from_tty, ¤t_target, auto_solib_add);
+ re_enable_breakpoints_in_shlibs ();
#endif
/* Take any necessary post-attaching actions for this platform.
*/
- target_post_attach (inferior_pid);
+ target_post_attach (PIDGET (inferior_ptid));
normal_stop ();
*/
static void
-detach_command (args, from_tty)
- char *args;
- int from_tty;
+detach_command (char *args, int from_tty)
{
dont_repeat (); /* Not for the faint of heart */
target_detach (args, from_tty);
/* Stop the execution of the target while running in async mode, in
the backgound. */
+
+void
+interrupt_target_command_wrapper (char *args, int from_tty)
+{
+ interrupt_target_command (args, from_tty);
+}
+
static void
-interrupt_target_command (args, from_tty)
- char *args;
- int from_tty;
+interrupt_target_command (char *args, int from_tty)
{
if (event_loop_p && target_can_async_p ())
{
/* ARGSUSED */
static void
-float_info (addr_exp, from_tty)
- char *addr_exp;
- int from_tty;
+float_info (char *addr_exp, int from_tty)
{
-#ifdef FLOAT_INFO
- FLOAT_INFO;
-#else
- printf_filtered ("No floating point info available for this processor.\n");
-#endif
+ gdbarch_print_float_info (current_gdbarch, gdb_stdout, selected_frame);
}
\f
/* ARGSUSED */
static void
-unset_command (args, from_tty)
- char *args;
- int from_tty;
+unset_command (char *args, int from_tty)
{
printf_filtered ("\"unset\" must be followed by the name of ");
printf_filtered ("an unset subcommand.\n");
}
void
-_initialize_infcmd ()
+_initialize_infcmd (void)
{
struct cmd_list_element *c;
- add_com ("tty", class_run, tty_command,
- "Set terminal for future runs of program being debugged.");
+ c = add_com ("tty", class_run, tty_command,
+ "Set terminal for future runs of program being debugged.");
+ set_cmd_completer (c, filename_completer);
- add_show_from_set
- (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\
+ c = 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);
+ &setlist);
+ set_cmd_completer (c, filename_completer);
+ set_cmd_sfunc (c, notice_args_set);
+ c = add_show_from_set (c, &showlist);
+ set_cmd_sfunc (c, notice_args_read);
c = add_cmd
("environment", no_class, environment_info,
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.", &showlist);
- c->completer = noop_completer;
+ set_cmd_completer (c, noop_completer);
add_prefix_cmd ("unset", no_class, unset_command,
- "Complement to certain \"set\" commands",
+ "Complement to certain \"set\" commands.",
&unsetlist, "unset ", 0, &cmdlist);
c = 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.",
&unsetlist);
- c->completer = noop_completer;
+ set_cmd_completer (c, noop_completer);
c = add_cmd ("environment", class_run, set_environment_command,
"Set environment variable value to give the program.\n\
VALUES of environment variables are uninterpreted strings.\n\
This does not affect the program until the next \"run\" command.",
&setlist);
- c->completer = noop_completer;
+ set_cmd_completer (c, noop_completer);
- add_com ("path", class_files, path_command,
- "Add directory DIR(s) to beginning of search path for object files.\n\
+ c = add_com ("path", class_files, path_command,
+ "Add directory DIR(s) to beginning of search path for object files.\n\
$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.");
+ set_cmd_completer (c, filename_completer);
c = add_cmd ("paths", no_class, path_info,
"Current search path for finding object files.\n\
directories, separated by colons. These directories are searched to find\n\
fully linked executable files and separately compiled object files as needed.",
&showlist);
- c->completer = noop_completer;
+ set_cmd_completer (c, noop_completer);
add_com ("attach", class_run, attach_command,
"Attach to a process or file outside of GDB.\n\
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\
+ c = 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.");
+ set_cmd_completer (c, location_completer);
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\
+ c = 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\
for an address to start at.");
+ set_cmd_completer (c, location_completer);
if (xdb_commands)
- add_com ("go", class_run, go_command,
- "Usage: go <location>\n\
+ {
+ c = 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.");
+ set_cmd_completer (c, location_completer);
+ }
if (xdb_commands)
add_com_alias ("g", "go", class_run, 1);
add_com_alias ("c", "cont", class_run, 1);
add_com_alias ("fg", "cont", class_run, 1);
- add_com ("run", class_run, run_command,
+ c = add_com ("run", class_run, run_command,
"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\
To cancel previous arguments and run with no arguments,\n\
use \"set args\" without arguments.");
+ set_cmd_completer (c, filename_completer);
add_com_alias ("r", "run", class_run, 1);
if (xdb_commands)
add_com ("R", class_run, run_no_args_command,
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.");
+ add_info_alias ("r", "registers", 1);
if (xdb_commands)
add_com ("lr", class_info, nofp_registers_info,
add_info ("float", float_info,
"Print the status of the floating point unit\n");
- inferior_args = savestring ("", 1); /* Initially no args */
inferior_environ = make_environ ();
init_environ (inferior_environ);
}
projects / deliverable / binutils-gdb.git / blobdiff