inferior_io_terminal = savestring (file, strlen (file));
}
-static void
-run_command (char *args, int from_tty)
-{
- char *exec_file;
-
- dont_repeat ();
+/* Kill the inferior if already running. This function is designed
+ to be called when we are about to start the execution of the program
+ from the beginning. Ask the user to confirm that he wants to restart
+ the program being debugged when FROM_TTY is non-null. */
+void
+kill_if_already_running (int from_tty)
+{
if (! ptid_equal (inferior_ptid, null_ptid) && target_has_execution)
{
if (from_tty
#endif
init_wait_for_inferior ();
}
+}
+
+static void
+run_command (char *args, int from_tty)
+{
+ char *exec_file;
+
+ dont_repeat ();
+ kill_if_already_running (from_tty);
clear_breakpoint_hit_counts ();
/* Purge old solib objfiles. */
/* 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));
+ environ_vector (inferior_environ), from_tty);
}
}
\f
+/* Start the execution of the program up until the beginning of the main
+ program. */
+
+static void
+start_command (char *args, int from_tty)
+{
+ /* Some languages such as Ada need to search inside the program
+ minimal symbols for the location where to put the temporary
+ breakpoint before starting. */
+ if (!have_minimal_symbols ())
+ error ("No symbol table loaded. Use the \"file\" command.");
+
+ /* If the inferior is already running, we want to ask the user if we
+ should restart it or not before we insert the temporary breakpoint.
+ This makes sure that this command doesn't have any side effect if
+ the user changes its mind. */
+ kill_if_already_running (from_tty);
+
+ /* Insert the temporary breakpoint, and run... */
+ tbreak_command (main_name (), 0);
+ run_command (args, from_tty);
+}
+
void
continue_command (char *proc_count_exp, int from_tty)
{
until_break_command (arg, from_tty, 1);
}
\f
-
-static struct value *
-legacy_return_value (int struct_return, struct type *value_type)
-{
- struct value *value;
-
- if (!struct_return)
- {
- /* The return value can be found in the inferior's registers. */
- return register_value_being_returned (value_type, stop_registers);
- }
-
- if (DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS_P ())
- {
- CORE_ADDR addr;
-
- addr = DEPRECATED_EXTRACT_STRUCT_VALUE_ADDRESS (stop_registers);
- if (!addr)
- error ("Function return value unknown.");
- return value_at (value_type, addr, NULL);
- }
-
- /* 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));
- return value;
-}
-
/* Print the result of a function at the end of a 'finish' command. */
static void
struct gdbarch *gdbarch = current_gdbarch;
struct cleanup *old_chain;
struct ui_stream *stb;
- struct value *value = NULL;
+ struct value *value;
+
+ gdb_assert (TYPE_CODE (value_type) != TYPE_CODE_VOID);
/* FIXME: 2003-09-27: When returning from a nested inferior function
call, it's possible (with no help from the architecture vector)
inferior function call code. In fact, when inferior function
calls are made async, this will likely be made the norm. */
- if (gdbarch_return_value_p (gdbarch))
+ switch (gdbarch_return_value (gdbarch, value_type, NULL, NULL, NULL))
{
- switch (gdbarch_return_value (gdbarch, value_type, NULL, NULL, NULL))
- {
- case RETURN_VALUE_REGISTER_CONVENTION:
- case RETURN_VALUE_ABI_RETURNS_ADDRESS:
- value = allocate_value (value_type);
- CHECK_TYPEDEF (value_type);
- gdbarch_return_value (current_gdbarch, value_type, stop_registers,
- VALUE_CONTENTS_RAW (value), NULL);
- break;
-
- case RETURN_VALUE_STRUCT_CONVENTION:
- break;
- }
+ case RETURN_VALUE_REGISTER_CONVENTION:
+ case RETURN_VALUE_ABI_RETURNS_ADDRESS:
+ value = allocate_value (value_type);
+ CHECK_TYPEDEF (value_type);
+ gdbarch_return_value (current_gdbarch, value_type, stop_registers,
+ VALUE_CONTENTS_RAW (value), NULL);
+ break;
+ case RETURN_VALUE_STRUCT_CONVENTION:
+ value = NULL;
+ break;
+ default:
+ internal_error (__FILE__, __LINE__, "bad switch");
}
- else
- value = legacy_return_value (struct_return, value_type);
if (value)
{
target_files_info ();
printf_filtered ("Program stopped at %s.\n",
- local_hex_string ((unsigned long) stop_pc));
+ hex_string ((unsigned long) stop_pc));
if (stop_step)
printf_filtered ("It stopped after being stepped.\n");
else if (num != 0)
{
int i;
const int numregs = NUM_REGS + NUM_PSEUDO_REGS;
- char raw_buffer[MAX_REGISTER_SIZE];
- char virtual_buffer[MAX_REGISTER_SIZE];
-
- if (DEPRECATED_DO_REGISTERS_INFO_P ())
- {
- DEPRECATED_DO_REGISTERS_INFO (regnum, print_all);
- return;
- }
+ char buffer[MAX_REGISTER_SIZE];
for (i = 0; i < numregs; i++)
{
print_spaces_filtered (15 - strlen (REGISTER_NAME (i)), file);
/* Get the data in raw format. */
- if (! frame_register_read (frame, i, raw_buffer))
+ if (! frame_register_read (frame, i, buffer))
{
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 (DEPRECATED_REGISTER_CONVERTIBLE_P ()
- && DEPRECATED_REGISTER_CONVERTIBLE (i))
- {
- DEPRECATED_REGISTER_CONVERT_TO_VIRTUAL (i, register_type (current_gdbarch, i),
- raw_buffer, virtual_buffer);
- }
- else
- {
- memcpy (virtual_buffer, raw_buffer,
- DEPRECATED_REGISTER_VIRTUAL_SIZE (i));
- }
-
/* If virtual format is floating, print it that way, and in raw
hex. */
if (TYPE_CODE (register_type (current_gdbarch, i)) == TYPE_CODE_FLT)
{
int j;
- val_print (register_type (current_gdbarch, i), virtual_buffer, 0, 0,
+ val_print (register_type (current_gdbarch, i), buffer, 0, 0,
file, 0, 1, 0, Val_pretty_default);
fprintf_filtered (file, "\t(raw 0x");
- for (j = 0; j < DEPRECATED_REGISTER_RAW_SIZE (i); j++)
+ for (j = 0; j < register_size (current_gdbarch, i); j++)
{
int idx;
if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
idx = j;
else
- idx = DEPRECATED_REGISTER_RAW_SIZE (i) - 1 - j;
- fprintf_filtered (file, "%02x", (unsigned char) raw_buffer[idx]);
+ idx = register_size (current_gdbarch, i) - 1 - j;
+ fprintf_filtered (file, "%02x", (unsigned char) buffer[idx]);
}
fprintf_filtered (file, ")");
}
else
{
/* Print the register in hex. */
- val_print (register_type (current_gdbarch, i), virtual_buffer, 0, 0,
+ val_print (register_type (current_gdbarch, i), buffer, 0, 0,
file, 'x', 1, 0, Val_pretty_default);
/* If not a vector register, print it also according to its
natural format. */
if (TYPE_VECTOR (register_type (current_gdbarch, i)) == 0)
{
fprintf_filtered (file, "\t");
- val_print (register_type (current_gdbarch, i), virtual_buffer, 0, 0,
+ val_print (register_type (current_gdbarch, i), buffer, 0, 0,
file, 0, 1, 0, Val_pretty_default);
}
}
based on what modes we are starting it with. */
target_terminal_init ();
- /* Install inferior's terminal modes. */
- target_terminal_inferior ();
-
/* Set up execution context to know that we should return from
wait_for_inferior as soon as the target reports a stop. */
init_wait_for_inferior ();
*/
target_post_attach (PIDGET (inferior_ptid));
+ /* Install inferior's terminal modes. */
+ target_terminal_inferior ();
+
normal_stop ();
if (deprecated_attach_hook)
&setlist);
set_cmd_completer (c, filename_completer);
set_cmd_sfunc (c, notice_args_set);
- c = add_show_from_set (c, &showlist);
+ c = deprecated_add_show_from_set (c, &showlist);
set_cmd_sfunc (c, notice_args_read);
c = add_cmd
add_com ("R", class_run, run_no_args_command,
"Start debugged program with no arguments.");
+ c = add_com ("start", class_run, start_command,
+ "\
+Run the debugged program until the beginning of the main procedure.\n\
+You may specify arguments to give to your program, just as with the\n\
+\"run\" command.");
+ set_cmd_completer (c, filename_completer);
+
add_com ("interrupt", class_run, interrupt_target_command,
"Interrupt the execution of the debugged program.");
projects / deliverable / binutils-gdb.git / blobdiff