#include "language.h"
#include "symfile.h"
#include "objfiles.h"
+#ifdef UI_OUT
+#include "ui-out.h"
+#endif
#include "event-top.h"
#include "parser-defs.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.");
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
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;
if (from_tty)
{
+#ifdef UI_OUT
+ ui_out_field_string (uiout, NULL, "Starting program");
+ ui_out_text (uiout, ": ");
+ if (exec_file)
+ ui_out_field_string (uiout, "execfile", exec_file);
+ ui_out_spaces (uiout, 1);
+ ui_out_field_string (uiout, "infargs", inferior_args);
+ ui_out_text (uiout, "\n");
+ ui_out_flush (uiout);
+#else
puts_filtered ("Starting program: ");
if (exec_file)
puts_filtered (exec_file);
puts_filtered (inferior_args);
puts_filtered ("\n");
gdb_flush (gdb_stdout);
+#endif
}
target_create_inferior (exec_file, inferior_args,
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);
\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
called in case of step n with n>1, after the first step operation has
been completed.*/
static void
-step_once (int skip_subroutines, int single_inst, int count)
+step_once (int skip_subroutines, int single_inst, int count)
{
- struct continuation_arg *arg1; struct continuation_arg *arg2;
- struct continuation_arg *arg3; struct frame_info *frame;
+ struct continuation_arg *arg1;
+ struct continuation_arg *arg2;
+ struct continuation_arg *arg3;
+ struct frame_info *frame;
if (count > 0)
{
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;
/* 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);
}
The dummy's frame is automatically popped whenever that break is hit.
If that is the first time the program stops, run_stack_dummy
returns to its caller with that frame already gone and returns 0.
- Otherwise, run_stack-dummy returns 1 (the frame will eventually be popped
- when we do hit that breakpoint). */
+
+ Otherwise, run_stack-dummy returns a non-zero value.
+ If the called function receives a random signal, we do not allow the user
+ to continue executing it as this may not work. The dummy frame is poped
+ and we return 1.
+ If we hit a breakpoint, we leave the frame in place and return 2 (the frame
+ 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, char *buffer)
{
struct cleanup *old_cleanups = make_cleanup (null_cleanup, 0);
int saved_async = 0;
discard_cleanups (old_cleanups);
- if (!stop_stack_dummy)
+ /* We can stop during an inferior call because a signal is received. */
+ if (stopped_by_random_signal)
return 1;
+
+ /* We may also stop prematurely because we hit a breakpoint in the
+ called routine. */
+ if (!stop_stack_dummy)
+ return 2;
- /* On return, the stack dummy has been popped already. */
+ /* On normal return, the stack dummy has been popped already. */
memcpy (buffer, stop_registers, REGISTER_BYTES);
return 0;
/* 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;
print_return_value (int structure_return, struct type *value_type)
{
register value_ptr value;
+#ifdef UI_OUT
+ static struct ui_stream *stb = NULL;
+#endif /* UI_OUT */
if (!structure_return)
{
value = value_being_returned (value_type, stop_registers, structure_return);
+#ifdef UI_OUT
+ 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 /* UI_OUT */
printf_filtered ("Value returned is $%d = ", record_latest_value (value));
value_print (value, gdb_stdout, 0, Val_no_prettyprint);
printf_filtered ("\n");
+#endif /* UI_OUT */
}
else
{
initiate the call, as opposed to the call_function_by_hand case */
#ifdef VALUE_RETURNED_FROM_STACK
value = 0;
+#ifdef UI_OUT
+ 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 /* UI_OUT */
printf_filtered ("Value returned has type: %s.", TYPE_NAME (value_type));
printf_filtered (" Cannot determine contents\n");
+#endif /* UI_OUT */
#else
value = value_being_returned (value_type, stop_registers, structure_return);
+#ifdef UI_OUT
+ 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
printf_filtered ("Value returned is $%d = ", record_latest_value (value));
value_print (value, gdb_stdout, 0, Val_no_prettyprint);
printf_filtered ("\n");
+#endif
#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;
+ 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)
if (TYPE_CODE (value_type) == TYPE_CODE_VOID)
{
- do_exec_cleanups (ALL_CLEANUPS);
+ do_exec_cleanups (cleanups);
return;
}
print_return_value (struct_return, value_type);
}
- do_exec_cleanups (ALL_CLEANUPS);
+ do_exec_cleanups (cleanups);
}
/* "finish": Set a temporary breakpoint at the place
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;
register struct symbol *function;
struct breakpoint *breakpoint;
struct cleanup *old_chain;
- struct continuation_arg *arg1, *arg2;
+ struct continuation_arg *arg1, *arg2, *arg3;
int async_exec = 0;
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
- make_exec_cleanup ((make_cleanup_func) delete_breakpoint, breakpoint);
+ old_chain = make_exec_cleanup_delete_breakpoint (breakpoint);
/* Find the function we will return from. */
(struct continuation_arg *) xmalloc (sizeof (struct continuation_arg));
arg2 =
(struct continuation_arg *) xmalloc (sizeof (struct continuation_arg));
+ arg3 =
+ (struct continuation_arg *) xmalloc (sizeof (struct continuation_arg));
arg1->next = arg2;
- arg2->next = NULL;
- arg1->data = (PTR) breakpoint;
- arg2->data = (PTR) function;
+ arg2->next = arg3;
+ arg3->next = NULL;
+ arg1->data.pointer = breakpoint;
+ arg2->data.pointer = function;
+ arg3->data.pointer = old_chain;
add_continuation (finish_command_continuation, arg1);
}
\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;
}
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;
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;
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;
}
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;
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
*/
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. */
+#ifdef UI_OUT
+void
+interrupt_target_command_wrapper (char *args, int from_tty)
+{
+ interrupt_target_command (args, from_tty);
+}
+#endif
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;
\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_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,