/* Memory-access and commands for "inferior" process, for GDB.
Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
- 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003
+ 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
Free Software Foundation, Inc.
This file is part of GDB.
#include "reggroups.h"
#include "block.h"
#include <ctype.h>
+#include "gdb_assert.h"
/* Functions exported for general use, in inferior.h: */
\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)
{
return 0;
}
-/* ARGSUSED */
void
tty_command (char *file, int from_tty)
{
\f
/* Step until outside of current statement. */
-/* ARGSUSED */
static void
step_command (char *count_string, int from_tty)
{
/* Likewise, but skip over subroutine calls as if single instructions. */
-/* ARGSUSED */
static void
next_command (char *count_string, int from_tty)
{
/* Likewise, but step only one instruction. */
-/* ARGSUSED */
void
stepi_command (char *count_string, int from_tty)
{
step_1 (0, 1, count_string);
}
-/* ARGSUSED */
void
nexti_command (char *count_string, int from_tty)
{
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)
- SHIFT_INST_REGS ();
-#endif
}
if (!single_inst || skip_subroutines)
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 ();
-#endif
- step_once (skip_subroutines, single_inst, count - 1);
- }
+ step_once (skip_subroutines, single_inst, count - 1);
else
if (!single_inst || skip_subroutines)
do_exec_cleanups (ALL_CLEANUPS);
we set. This may involve changes to wait_for_inferior and the
proceed status code. */
-/* ARGSUSED */
static void
until_next_command (int from_tty)
{
}
\f
-/* Print the result of a function at the end of a 'finish' command. */
+/* Print the result of a function at the end of a 'finish' command. */
+
static void
-print_return_value (int structure_return, struct type *value_type)
+print_return_value (int struct_return, struct type *value_type)
{
+ struct cleanup *old_chain;
+ struct ui_stream *stb;
struct value *value;
- static struct ui_stream *stb = NULL;
- if (!structure_return)
+ if (!struct_return)
{
- value = value_being_returned (value_type, stop_registers, structure_return);
- 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");
+ /* The return value can be found in the inferior's registers. */
+ value = register_value_being_returned (value_type, stop_registers);
}
- else
+ /* FIXME: cagney/2004-01-17: When both return_value and
+ extract_returned_value_address are available, should use that to
+ find the address of and then extract the returned value. */
+ /* FIXME: 2003-09-27: When returning from a nested inferior function
+ call, it's possible (with no help from the architecture vector)
+ to locate and return/print a "struct return" value. This is just
+ a more complicated case of what is already being done in in the
+ inferior function call code. In fact, when inferior function
+ calls are made async, this will likely be made the norm. */
+ else if (gdbarch_return_value_p (current_gdbarch))
+ /* We cannot determine the contents of the structure because it is
+ on the stack, and we don't know where, since we did not
+ initiate the call, as opposed to the call_function_by_hand
+ case. */
{
- /* We cannot determine the contents of the structure because
- it is on the stack, and we don't know where, since we did not
- initiate the call, as opposed to the call_function_by_hand case */
-#ifdef VALUE_RETURNED_FROM_STACK
- value = 0;
+ gdb_assert (gdbarch_return_value (current_gdbarch, value_type,
+ NULL, NULL, NULL)
+ == RETURN_VALUE_STRUCT_CONVENTION);
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);
- 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
+ return;
+ }
+ else
+ {
+ if (DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P ())
+ {
+ CORE_ADDR addr = DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS (stop_registers);
+ if (!addr)
+ error ("Function return value unknown.");
+ value = value_at (value_type, addr, NULL);
+ }
+ else
+ {
+ /* It is "struct return" yet the value is being extracted,
+ presumably from registers, using EXTRACT_RETURN_VALUE.
+ This doesn't make sense. Unfortunately, the legacy
+ interfaces allowed this behavior. Sigh! */
+ value = allocate_value (value_type);
+ CHECK_TYPEDEF (value_type);
+ /* If the function returns void, don't bother fetching the
+ return value. */
+ EXTRACT_RETURN_VALUE (value_type, stop_registers,
+ VALUE_CONTENTS_RAW (value));
+ }
}
+
+ /* Print it. */
+ stb = ui_out_stream_new (uiout);
+ old_chain = make_cleanup_ui_out_stream_delete (stb);
+ 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");
+ do_cleanups (old_chain);
}
/* Stuff that needs to be done by the finish command after the target
- has stopped. In asynchronous mode, we wait for the target to stop in
- the call to poll or select in the event loop, so it is impossible to
- do all the stuff as part of the finish_command function itself. The
- 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_continuation pointer. */
-void
+ has stopped. In asynchronous mode, we wait for the target to stop
+ in the call to poll or select in the event loop, so it is
+ impossible to do all the stuff as part of the finish_command
+ function itself. The 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_continuation pointer. */
+
+static void
finish_command_continuation (struct continuation_arg *arg)
{
struct symbol *function;
struct cleanup *cleanups;
breakpoint = (struct breakpoint *) arg->data.pointer;
- function = (struct symbol *) arg->next->data.pointer;
- cleanups = (struct cleanup *) arg->next->next->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)
+ && function != NULL)
{
struct type *value_type;
- CORE_ADDR funcaddr;
int struct_return;
+ int gcc_compiled;
value_type = TYPE_TARGET_TYPE (SYMBOL_TYPE (function));
if (!value_type)
return;
}
- funcaddr = BLOCK_START (SYMBOL_BLOCK_VALUE (function));
-
- struct_return = using_struct_return (check_typedef (value_type),
- BLOCK_GCC_COMPILED (SYMBOL_BLOCK_VALUE (function)));
+ CHECK_TYPEDEF (value_type);
+ gcc_compiled = BLOCK_GCC_COMPILED (SYMBOL_BLOCK_VALUE (function));
+ struct_return = using_struct_return (value_type, gcc_compiled);
print_return_value (struct_return, value_type);
}
+
do_exec_cleanups (cleanups);
}
-/* "finish": Set a temporary breakpoint at the place
- the selected frame will return to, then continue. */
+/* "finish": Set a temporary breakpoint at the place the selected
+ frame will return to, then continue. */
static void
finish_command (char *arg, int from_tty)
int async_exec = 0;
- /* Find out whether we must run in the background. */
+ /* Find out whether we must run in the background. */
if (arg != NULL)
async_exec = strip_bg_char (&arg);
/* If we must run in the background, but the target can't do it,
- error out. */
+ error out. */
if (event_loop_p && async_exec && !target_can_async_p ())
error ("Asynchronous execution not supported on this target.");
/* If we are not asked to run in the bg, then prepare to run in the
- foreground, synchronously. */
+ foreground, synchronously. */
if (event_loop_p && !async_exec && target_can_async_p ())
{
- /* Simulate synchronous execution */
+ /* Simulate synchronous execution. */
async_disable_stdin ();
}
function = find_pc_function (get_frame_pc (deprecated_selected_frame));
- /* Print info on the selected frame, including level number
- but not source. */
+ /* Print info on the selected frame, including level number but not
+ source. */
if (from_tty)
{
printf_filtered ("Run till exit from ");
/* If running asynchronously and the target support asynchronous
execution, set things up for the rest of the finish command to be
completed later on, when gdb has detected that the target has
- stopped, in fetch_inferior_event. */
+ stopped, in fetch_inferior_event. */
if (event_loop_p && target_can_async_p ())
{
arg1 =
add_continuation (finish_command_continuation, arg1);
}
- proceed_to_finish = 1; /* We want stop_registers, please... */
+ proceed_to_finish = 1; /* We want stop_registers, please... */
proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 0);
/* Do this only if not running asynchronously or if the target
- cannot do async execution. Otherwise, complete this command when
- the target actually stops, in fetch_inferior_event. */
+ cannot do async execution. Otherwise, complete this command when
+ the target actually stops, in fetch_inferior_event. */
if (!event_loop_p || !target_can_async_p ())
{
-
- /* Did we stop at our breakpoint? */
+ /* Did we stop at our breakpoint? */
if (bpstat_find_breakpoint (stop_bpstat, breakpoint) != NULL
- && function != 0)
+ && function != NULL)
{
struct type *value_type;
- CORE_ADDR funcaddr;
int struct_return;
+ int gcc_compiled;
value_type = TYPE_TARGET_TYPE (SYMBOL_TYPE (function));
if (!value_type)
internal_error (__FILE__, __LINE__,
"finish_command: function has no target type");
- /* FIXME: Shouldn't we do the cleanups before returning? */
+ /* FIXME: Shouldn't we do the cleanups before returning? */
if (TYPE_CODE (value_type) == TYPE_CODE_VOID)
return;
- funcaddr = BLOCK_START (SYMBOL_BLOCK_VALUE (function));
-
- struct_return =
- using_struct_return (check_typedef (value_type),
- BLOCK_GCC_COMPILED (SYMBOL_BLOCK_VALUE (function)));
+ CHECK_TYPEDEF (value_type);
+ gcc_compiled = BLOCK_GCC_COMPILED (SYMBOL_BLOCK_VALUE (function));
+ struct_return = using_struct_return (value_type, gcc_compiled);
print_return_value (struct_return, value_type);
}
+
do_cleanups (old_chain);
}
}
\f
-/* ARGSUSED */
+
static void
program_info (char *args, int from_tty)
{
{
if (var)
{
- register char *val = get_in_environ (inferior_environ, var);
+ char *val = get_in_environ (inferior_environ, var);
if (val)
{
puts_filtered (var);
}
else
{
- register char **vector = environ_vector (inferior_environ);
+ char **vector = environ_vector (inferior_environ);
while (*vector)
{
puts_filtered (*vector++);
static const char path_var_name[] = "PATH";
-/* ARGSUSED */
static void
path_info (char *args, int from_tty)
{
}
\f
-#ifdef REGISTER_NAMES
-char *gdb_register_names[] = REGISTER_NAMES;
-#endif
/* 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).
else
{
memcpy (virtual_buffer, raw_buffer,
- REGISTER_VIRTUAL_SIZE (i));
+ DEPRECATED_REGISTER_VIRTUAL_SIZE (i));
}
/* If virtual format is floating, print it that way, and in raw
file, 0, 1, 0, Val_pretty_default);
fprintf_filtered (file, "\t(raw 0x");
- for (j = 0; j < REGISTER_RAW_SIZE (i); j++)
+ for (j = 0; j < DEPRECATED_REGISTER_RAW_SIZE (i); j++)
{
int idx;
if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
idx = j;
else
- idx = REGISTER_RAW_SIZE (i) - 1 - j;
+ idx = DEPRECATED_REGISTER_RAW_SIZE (i) - 1 - j;
fprintf_filtered (file, "%02x", (unsigned char) raw_buffer[idx]);
}
fprintf_filtered (file, ")");
}
}
-/* ARGSUSED */
static void
print_float_info (struct gdbarch *gdbarch, struct ui_file *file,
struct frame_info *frame, const char *args)
print_float_info (current_gdbarch, gdb_stdout, deprecated_selected_frame, args);
}
\f
-/* ARGSUSED */
static void
unset_command (char *args, int from_tty)
{