#include "ui-out.h"
#include "event-top.h"
#include "parser-defs.h"
+#include "regcache.h"
+#include "reggroups.h"
+#include <ctype.h>
-/* Functions exported for general use: */
-
-void nofp_registers_info (char *, int);
+/* Functions exported for general use, in inferior.h: */
void all_registers_info (char *, int);
void registers_info (char *, int);
-/* Local functions: */
+void nexti_command (char *, int);
+
+void stepi_command (char *, int);
void continue_command (char *, int);
+void interrupt_target_command (char *args, int from_tty);
+
+/* Local functions: */
+
+static void nofp_registers_info (char *, int);
+
static void print_return_value (int struct_return, struct type *value_type);
static void finish_command_continuation (struct continuation_arg *);
static void detach_command (char *, int);
-static void interrupt_target_command (char *args, int from_tty);
-
static void unset_environment_command (char *, int);
static void set_environment_command (char *, int);
static void step_once (int skip_subroutines, int single_inst, int count);
static void step_1_continuation (struct continuation_arg *arg);
-void nexti_command (char *, int);
-
-void stepi_command (char *, int);
-
static void next_command (char *, int);
static void step_command (char *, int);
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_address;
+struct frame_id step_frame_id;
/* Our notion of the current stack pointer. */
/* Notice when `show args' is run. */
static void
-notice_args_read (struct cmd_list_element *c)
+notice_args_read (char *args, int from_tty, struct cmd_list_element *c)
{
/* Might compute the value. */
get_inferior_args ();
/* We over-compute the size. It shouldn't matter. */
for (i = 0; i < argc; ++i)
- length += 2 * strlen (argv[i]) + 1;
+ length += 2 * strlen (argv[i]) + 1 + 2 * (argv[i][0] == '\0');
result = (char *) xmalloc (length);
out = result;
if (i > 0)
*out++ = ' ';
- for (cp = argv[i]; *cp; ++cp)
+ /* Need to handle empty arguments specially. */
+ if (argv[i][0] == '\0')
{
- if (strchr (special, *cp) != NULL)
- *out++ = '\\';
- *out++ = *cp;
+ *out++ = '\'';
+ *out++ = '\'';
+ }
+ else
+ {
+ for (cp = argv[i]; *cp; ++cp)
+ {
+ if (strchr (special, *cp) != NULL)
+ *out++ = '\\';
+ *out++ = *cp;
+ }
}
}
*out = '\0';
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
frame = get_current_frame ();
if (!frame) /* Avoid coredump here. Why tho? */
error ("No current frame");
- step_frame_address = FRAME_FP (frame);
+ step_frame_id = get_frame_id (frame);
step_sp = read_sp ();
if (!single_inst)
frame = get_current_frame ();
if (!frame) /* Avoid coredump here. Why tho? */
error ("No current frame");
- step_frame_address = FRAME_FP (frame);
+ step_frame_id = get_frame_id (frame);
step_sp = read_sp ();
if (!single_inst)
will eventually be popped when we do hit the dummy end breakpoint). */
int
-run_stack_dummy (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;
struct breakpoint *bpt;
struct symtab_and_line sal;
- INIT_SAL (&sal); /* initialize to zeroes */
+ init_sal (&sal); /* initialize to zeroes */
if (CALL_DUMMY_LOCATION == AT_ENTRY_POINT)
{
sal.pc = CALL_DUMMY_ADDRESS ();
addr is the address of the call dummy plus the CALL_DUMMY_START_OFFSET,
so we need to subtract the CALL_DUMMY_START_OFFSET. */
+ /* FIXME: cagney/2002-12-01: Rather than pass in curent frame,
+ why not just create, and then pass in a frame ID. This would
+ make it possible to eliminate set_current_frame(). */
bpt = set_momentary_breakpoint (sal,
- get_current_frame (),
+ get_frame_id (get_current_frame ()),
bp_call_dummy);
bpt->disposition = disp_del;
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
}
step_over_calls = STEP_OVER_ALL;
- step_frame_address = FRAME_FP (frame);
+ step_frame_id = get_frame_id (frame);
step_sp = read_sp ();
step_multi = 0; /* Only one call to proceed */
error ("The \"finish\" command does not take any arguments.");
if (!target_has_execution)
error ("The program is not running.");
- if (selected_frame == NULL)
+ if (deprecated_selected_frame == NULL)
error ("No selected frame.");
- frame = get_prev_frame (selected_frame);
+ frame = get_prev_frame (deprecated_selected_frame);
if (frame == 0)
error ("\"finish\" not meaningful in the outermost frame.");
clear_proceed_status ();
- sal = find_pc_line (frame->pc, 0);
- sal.pc = frame->pc;
+ sal = find_pc_line (get_frame_pc (frame), 0);
+ sal.pc = get_frame_pc (frame);
- breakpoint = set_momentary_breakpoint (sal, frame, bp_finish);
+ breakpoint = set_momentary_breakpoint (sal, get_frame_id (frame), bp_finish);
if (!event_loop_p || !target_can_async_p ())
old_chain = make_cleanup_delete_breakpoint (breakpoint);
/* Find the function we will return from. */
- function = find_pc_function (selected_frame->pc);
+ function = find_pc_function (get_frame_pc (deprecated_selected_frame));
/* Print info on the selected frame, including level number
but not source. */
if (from_tty)
{
printf_filtered ("Run till exit from ");
- print_stack_frame (selected_frame, selected_frame_level, 0);
+ print_stack_frame (deprecated_selected_frame,
+ frame_relative_level (deprecated_selected_frame), 0);
}
/* If running asynchronously and the target support asynchronous
#ifdef REGISTER_NAMES
char *gdb_register_names[] = REGISTER_NAMES;
#endif
-/* Print out the machine register regnum. If regnum is -1,
- print all registers (fpregs == 1) or all non-float registers
- (fpregs == 0).
+/* Print out the machine register regnum. If regnum is -1, print all
+ registers (print_all == 1) or all non-float and non-vector
+ registers (print_all == 0).
For most machines, having all_registers_info() print the
- register(s) one per line is good enough. If a different format
- is required, (eg, for MIPS or Pyramid 90x, which both have
- lots of regs), or there is an existing convention for showing
- all the registers, define the macro DO_REGISTERS_INFO(regnum, fp)
- to provide that format. */
+ register(s) one per line is good enough. If a different format is
+ required, (eg, for MIPS or Pyramid 90x, which both have lots of
+ regs), or there is an existing convention for showing all the
+ registers, define the architecture method PRINT_REGISTERS_INFO to
+ provide that format. */
void
-do_registers_info (int regnum, int fpregs)
+default_print_registers_info (struct gdbarch *gdbarch,
+ struct ui_file *file,
+ struct frame_info *frame,
+ int regnum, int print_all)
{
- register int i;
- 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);
+ int i;
+ const int numregs = NUM_REGS + NUM_PSEUDO_REGS;
+ char *raw_buffer = alloca (MAX_REGISTER_RAW_SIZE);
+ char *virtual_buffer = alloca (MAX_REGISTER_VIRTUAL_SIZE);
+
+ if (DEPRECATED_DO_REGISTERS_INFO_P ())
+ {
+ DEPRECATED_DO_REGISTERS_INFO (regnum, print_all);
+ return;
+ }
for (i = 0; i < numregs; i++)
{
- /* Decide between printing all regs, nonfloat regs, or specific reg. */
+ /* Decide between printing all regs, non-float / vector regs, or
+ specific reg. */
if (regnum == -1)
{
- if (TYPE_CODE (REGISTER_VIRTUAL_TYPE (i)) == TYPE_CODE_FLT && !fpregs)
- continue;
+ if (print_all)
+ {
+ if (!gdbarch_register_reggroup_p (gdbarch, i, all_reggroup))
+ continue;
+ }
+ else
+ {
+ if (!gdbarch_register_reggroup_p (gdbarch, i, general_reggroup))
+ continue;
+ }
}
else
{
if (REGISTER_NAME (i) == NULL || *(REGISTER_NAME (i)) == '\0')
continue;
- fputs_filtered (REGISTER_NAME (i), gdb_stdout);
- print_spaces_filtered (15 - strlen (REGISTER_NAME (i)), gdb_stdout);
+ fputs_filtered (REGISTER_NAME (i), file);
+ print_spaces_filtered (15 - strlen (REGISTER_NAME (i)), file);
/* Get the data in raw format. */
- if (read_relative_register_raw_bytes (i, raw_buffer))
+ if (! frame_register_read (frame, i, raw_buffer))
{
- printf_filtered ("*value not available*\n");
+ fprintf_filtered (file, "*value not available*\n");
continue;
}
+ /* FIXME: cagney/2002-08-03: This code shouldn't be necessary.
+ The function frame_register_read() should have returned the
+ pre-cooked register so no conversion is necessary. */
/* Convert raw data to virtual format if necessary. */
if (REGISTER_CONVERTIBLE (i))
{
REGISTER_VIRTUAL_SIZE (i));
}
- /* If virtual format is floating, print it that way, and in raw hex. */
+ /* If virtual format is floating, print it that way, and in raw
+ hex. */
if (TYPE_CODE (REGISTER_VIRTUAL_TYPE (i)) == TYPE_CODE_FLT)
{
- register int j;
+ 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,
+ file, 0, 1, 0, Val_pretty_default);
- printf_filtered ("\t(raw 0x");
+ fprintf_filtered (file, "\t(raw 0x");
for (j = 0; j < REGISTER_RAW_SIZE (i); 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]);
+ int idx;
+ if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
+ idx = j;
+ else
+ idx = REGISTER_RAW_SIZE (i) - 1 - j;
+ fprintf_filtered (file, "%02x", (unsigned char) raw_buffer[idx]);
}
- printf_filtered (")");
+ fprintf_filtered (file, ")");
}
- /* Else print as integer in hex and in decimal. */
else
{
+ /* Print the register in hex. */
val_print (REGISTER_VIRTUAL_TYPE (i), virtual_buffer, 0, 0,
- gdb_stdout, 'x', 1, 0, Val_pretty_default);
- printf_filtered ("\t");
- val_print (REGISTER_VIRTUAL_TYPE (i), virtual_buffer, 0, 0,
- gdb_stdout, 0, 1, 0, Val_pretty_default);
+ file, 'x', 1, 0, Val_pretty_default);
+ /* If not a vector register, print it also according to its
+ natural format. */
+ if (TYPE_VECTOR (REGISTER_VIRTUAL_TYPE (i)) == 0)
+ {
+ fprintf_filtered (file, "\t");
+ val_print (REGISTER_VIRTUAL_TYPE (i), virtual_buffer, 0, 0,
+ file, 0, 1, 0, Val_pretty_default);
+ }
}
- /* The SPARC wants to print even-numbered float regs as doubles
- in addition to printing them as floats. */
-#ifdef PRINT_REGISTER_HOOK
- PRINT_REGISTER_HOOK (i);
-#endif
-
- printf_filtered ("\n");
+ fprintf_filtered (file, "\n");
}
}
if (!target_has_registers)
error ("The program has no registers now.");
- if (selected_frame == NULL)
+ if (deprecated_selected_frame == NULL)
error ("No selected frame.");
if (!addr_exp)
{
- DO_REGISTERS_INFO (-1, fpregs);
+ gdbarch_print_registers_info (current_gdbarch, gdb_stdout,
+ deprecated_selected_frame, -1, fpregs);
return;
}
- do
+ while (*addr_exp != '\0')
{
- if (addr_exp[0] == '$')
- addr_exp++;
- end = addr_exp;
- while (*end != '\0' && *end != ' ' && *end != '\t')
- ++end;
- numregs = NUM_REGS + NUM_PSEUDO_REGS;
+ char *start;
+ const char *end;
- regnum = target_map_name_to_register (addr_exp, end - addr_exp);
- if (regnum >= 0)
- goto found;
-
- regnum = numregs;
+ /* Keep skipping leading white space. */
+ if (isspace ((*addr_exp)))
+ {
+ addr_exp++;
+ continue;
+ }
- 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);
+ /* Discard any leading ``$''. Check that there is something
+ resembling a register following it. */
+ if (addr_exp[0] == '$')
+ addr_exp++;
+ if (isspace ((*addr_exp)) || (*addr_exp) == '\0')
+ error ("Missing register name");
- found:
- DO_REGISTERS_INFO (regnum, fpregs);
+ /* Find the start/end of this register name/num/group. */
+ start = addr_exp;
+ while ((*addr_exp) != '\0' && !isspace ((*addr_exp)))
+ addr_exp++;
+ end = addr_exp;
+
+ /* Figure out what we've found and display it. */
+
+ /* A register name? */
+ {
+ int regnum = frame_map_name_to_regnum (start, end - start);
+ if (regnum >= 0)
+ {
+ gdbarch_print_registers_info (current_gdbarch, gdb_stdout,
+ deprecated_selected_frame, regnum, fpregs);
+ continue;
+ }
+ }
+
+ /* A register number? (how portable is this one?). */
+ {
+ char *endptr;
+ int regnum = strtol (start, &endptr, 0);
+ if (endptr == end
+ && regnum >= 0
+ && regnum < NUM_REGS + NUM_PSEUDO_REGS)
+ {
+ gdbarch_print_registers_info (current_gdbarch, gdb_stdout,
+ deprecated_selected_frame, regnum, fpregs);
+ continue;
+ }
+ }
+
+ /* A register group? */
+ {
+ struct reggroup *const *group;
+ for (group = reggroups (current_gdbarch);
+ (*group) != NULL;
+ group++)
+ {
+ /* Don't bother with a length check. Should the user
+ enter a short register group name, go with the first
+ group that matches. */
+ if (strncmp (start, reggroup_name ((*group)), end - start) == 0)
+ break;
+ }
+ if ((*group) != NULL)
+ {
+ int regnum;
+ for (regnum = 0; regnum < NUM_REGS + NUM_PSEUDO_REGS; regnum++)
+ {
+ if (gdbarch_register_reggroup_p (current_gdbarch, regnum,
+ (*group)))
+ gdbarch_print_registers_info (current_gdbarch,
+ gdb_stdout, deprecated_selected_frame,
+ regnum, fpregs);
+ }
+ continue;
+ }
+ }
- addr_exp = end;
- while (*addr_exp == ' ' || *addr_exp == '\t')
- ++addr_exp;
+ /* Nothing matched. */
+ error ("Invalid register `%.*s'", (int) (end - start), start);
}
- while (*addr_exp != '\0');
}
void
registers_info (addr_exp, 1);
}
-void
+static void
nofp_registers_info (char *addr_exp, int from_tty)
{
registers_info (addr_exp, 0);
}
+
+static void
+print_vector_info (struct gdbarch *gdbarch, struct ui_file *file,
+ struct frame_info *frame, const char *args)
+{
+ if (!target_has_registers)
+ error ("The program has no registers now.");
+ if (deprecated_selected_frame == NULL)
+ error ("No selected frame.");
+
+ if (gdbarch_print_vector_info_p (gdbarch))
+ gdbarch_print_vector_info (gdbarch, file, frame, args);
+ else
+ {
+ int regnum;
+ int printed_something = 0;
+
+ for (regnum = 0; regnum < NUM_REGS + NUM_PSEUDO_REGS; regnum++)
+ {
+ if (gdbarch_register_reggroup_p (gdbarch, regnum, vector_reggroup))
+ {
+ printed_something = 1;
+ gdbarch_print_registers_info (gdbarch, file, frame, regnum, 1);
+ }
+ }
+ if (!printed_something)
+ fprintf_filtered (file, "No vector information\n");
+ }
+}
+
+static void
+vector_info (char *args, int from_tty)
+{
+ print_vector_info (current_gdbarch, gdb_stdout, deprecated_selected_frame, args);
+}
\f
/*
/* 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 (char *args, int from_tty)
{
if (event_loop_p && target_can_async_p ())
/* ARGSUSED */
static void
-float_info (char *addr_exp, int from_tty)
+print_float_info (struct gdbarch *gdbarch, struct ui_file *file,
+ struct frame_info *frame, const char *args)
{
+ if (!target_has_registers)
+ error ("The program has no registers now.");
+ if (deprecated_selected_frame == NULL)
+ error ("No selected frame.");
+
+ if (gdbarch_print_float_info_p (gdbarch))
+ gdbarch_print_float_info (gdbarch, file, frame, args);
+ else
+ {
#ifdef FLOAT_INFO
- FLOAT_INFO;
+#if GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL
+#error "FLOAT_INFO defined in multi-arch"
+#endif
+ FLOAT_INFO;
#else
- printf_filtered ("No floating point info available for this processor.\n");
+ int regnum;
+ int printed_something = 0;
+
+ for (regnum = 0; regnum < NUM_REGS + NUM_PSEUDO_REGS; regnum++)
+ {
+ if (gdbarch_register_reggroup_p (gdbarch, regnum, float_reggroup))
+ {
+ printed_something = 1;
+ gdbarch_print_registers_info (gdbarch, file, frame, regnum, 1);
+ }
+ }
+ if (!printed_something)
+ fprintf_filtered (file, "\
+No floating-point info available for this processor.\n");
#endif
+ }
+}
+
+static void
+float_info (char *args, int from_tty)
+{
+ print_float_info (current_gdbarch, gdb_stdout, deprecated_selected_frame, args);
}
\f
/* ARGSUSED */
c = add_com ("tty", class_run, tty_command,
"Set terminal for future runs of program being debugged.");
- c->completer = filename_completer;
+ set_cmd_completer (c, filename_completer);
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);
- c->completer = filename_completer;
- c->function.sfunc = notice_args_set;
+ set_cmd_completer (c, filename_completer);
+ set_cmd_sfunc (c, notice_args_set);
c = add_show_from_set (c, &showlist);
- c->pre_show_hook = notice_args_read;
+ 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);
c = add_com ("path", class_files, path_command,
"Add directory DIR(s) to beginning of search path for object files.\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.");
- c->completer = filename_completer;
+ 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\
"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.");
- c->completer = location_completer;
+ set_cmd_completer (c, location_completer);
add_com_alias ("u", "until", class_run, 1);
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.");
- c->completer = location_completer;
+ set_cmd_completer (c, location_completer);
if (xdb_commands)
{
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.");
- c->completer = location_completer;
+ set_cmd_completer (c, location_completer);
}
if (xdb_commands)
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.");
- c->completer = filename_completer;
+ 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 ("float", float_info,
"Print the status of the floating point unit\n");
+ add_info ("vector", vector_info,
+ "Print the status of the vector unit\n");
+
inferior_environ = make_environ ();
init_environ (inferior_environ);
}
projects / deliverable / binutils-gdb.git / blobdiff