/* Memory-access and commands for "inferior" process, for GDB.
- Copyright 1986, 87, 88, 89, 91, 92, 95, 96, 1998
+ Copyright 1986, 87, 88, 89, 91, 92, 95, 96, 1998, 1999
Free Software Foundation, Inc.
This file is part of GDB.
#include "language.h"
#include "symfile.h"
#include "objfiles.h"
-#include "event-loop.h"
+#include "event-top.h"
+#include "parser-defs.h"
/* Functions exported for general use: */
void continue_command PARAMS ((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 until_next_command PARAMS ((int));
static void detach_command PARAMS ((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 jump_command PARAMS ((char *, int));
static void step_1 PARAMS ((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));
want them to go away (PR 2207). This is probably reasonable. */
if (!args)
- sync_execution = 1;
+ {
+ if (event_loop_p && target_can_async_p ())
+ async_disable_stdin ();
+ }
else
{
char *cmd;
/* If we get a request for running in the bg but the target
doesn't support it, error out. */
- if (async_p && async_exec && !target_has_async)
+ if (event_loop_p && async_exec && !target_can_async_p ())
error ("Asynchronous execution not supported on this target.");
/* If we don't get a request of running in the bg, then we need
to simulate synchronous (fg) execution. */
- if (async_p && !async_exec && target_has_async)
+ if (event_loop_p && !async_exec && target_can_async_p ())
{
/* Simulate synchronous execution */
- sync_execution = 1;
+ async_disable_stdin ();
}
/* If there were other args, beside '&', process them. */
/* If we must run in the background, but the target can't do it,
error out. */
- if (async_p && async_exec && !target_has_async)
+ 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. */
- if (async_p && !async_exec && target_has_async)
+ if (event_loop_p && !async_exec && target_can_async_p ())
{
/* Simulate synchronous execution */
- sync_execution = 1;
+ async_disable_stdin ();
}
/* If have argument (besides '&'), set proceed count of breakpoint
clear_proceed_status ();
- proceed ((CORE_ADDR) - 1, TARGET_SIGNAL_DEFAULT, 0);
+ proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 0);
}
\f
/* Step until outside of current statement. */
/* If we get a request for running in the bg but the target
doesn't support it, error out. */
- if (async_p && async_exec && !target_has_async)
+ if (event_loop_p && async_exec && !target_can_async_p ())
error ("Asynchronous execution not supported on this target.");
/* If we don't get a request of running in the bg, then we need
to simulate synchronous (fg) execution. */
- if (async_p && !async_exec && target_has_async)
+ if (event_loop_p && !async_exec && target_can_async_p ())
{
/* Simulate synchronous execution */
- sync_execution = 1;
+ async_disable_stdin ();
}
count = count_string ? parse_and_eval_address (count_string) : 1;
if (!single_inst || skip_subroutines) /* leave si command alone */
{
enable_longjmp_breakpoint ();
- cleanups = make_cleanup ((make_cleanup_func) disable_longjmp_breakpoint,
- 0);
+ if (!event_loop_p || !target_can_async_p ())
+ cleanups = make_cleanup ((make_cleanup_func) disable_longjmp_breakpoint,
+ 0);
+ else
+ make_exec_cleanup ((make_cleanup_func) disable_longjmp_breakpoint, 0);
}
- for (; count > 0; count--)
+ /* In synchronous case, all is well, just use the regular for loop. */
+ if (!event_loop_p || !target_can_async_p ())
+ {
+ for (; count > 0; count--)
+ {
+ clear_proceed_status ();
+
+ frame = get_current_frame ();
+ if (!frame) /* Avoid coredump here. Why tho? */
+ error ("No current frame");
+ step_frame_address = FRAME_FP (frame);
+ step_sp = read_sp ();
+
+ if (!single_inst)
+ {
+ find_pc_line_pc_range (stop_pc, &step_range_start, &step_range_end);
+ if (step_range_end == 0)
+ {
+ char *name;
+ if (find_pc_partial_function (stop_pc, &name, &step_range_start,
+ &step_range_end) == 0)
+ error ("Cannot find bounds of current function");
+
+ target_terminal_ours ();
+ printf_filtered ("\
+Single stepping until exit from function %s, \n\
+which has no line number information.\n", name);
+ }
+ }
+ else
+ {
+ /* Say we are stepping, but stop after one insn whatever it does. */
+ step_range_start = step_range_end = 1;
+ if (!skip_subroutines)
+ /* It is stepi.
+ Don't step over function calls, not even to functions lacking
+ line numbers. */
+ step_over_calls = 0;
+ }
+
+ if (skip_subroutines)
+ step_over_calls = 1;
+
+ step_multi = (count > 1);
+ proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 1);
+
+ 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)
+ do_cleanups (cleanups);
+ return;
+ }
+ /* In case of asynchronous target things get complicated, do only
+ one step for now, before returning control to the event loop. Let
+ the continuation figure out how many other steps we need to do,
+ and handle them one at the time, through step_once(). */
+ else
+ {
+ if (event_loop_p && target_can_async_p ())
+ step_once (skip_subroutines, single_inst, count);
+ }
+}
+
+/* Called after we are done with one step operation, to check whether
+ we need to step again, before we print the prompt and return control
+ to the user. If count is > 1, we will need to do one more call to
+ 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;
+{
+ 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). */
+#if defined (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);
+}
+
+/* Do just one step operation. If count >1 we will have to set up a
+ continuation to be done after the target stops (after this one
+ step). This is useful to implement the 'step n' kind of commands, in
+ case of asynchronous targets. We had to split step_1 into two parts,
+ one to be done before proceed() and one afterwards. This function is
+ 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)
+{
+ struct continuation_arg *arg1; struct continuation_arg *arg2;
+ struct continuation_arg *arg3; struct frame_info *frame;
+
+ if (count > 0)
{
clear_proceed_status ();
step_over_calls = 1;
step_multi = (count > 1);
- proceed ((CORE_ADDR) - 1, TARGET_SIGNAL_DEFAULT, 1);
- 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
+ arg1 =
+ (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;
+ arg1->data = (PTR) skip_subroutines;
+ arg2->next = arg3;
+ arg2->data = (PTR) single_inst;
+ arg3->next = NULL;
+ arg3->data = (PTR) count;
+ add_intermediate_continuation (step_1_continuation, arg1);
+ proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 1);
}
-
- if (!single_inst || skip_subroutines)
- do_cleanups (cleanups);
}
+
\f
/* Continue program at specified address. */
/* If we must run in the background, but the target can't do it,
error out. */
- if (async_p && async_exec && !target_has_async)
+ 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. */
- if (async_p && !async_exec && target_has_async)
+ if (event_loop_p && !async_exec && target_can_async_p ())
{
/* Simulate synchronous execution */
- sync_execution = 1;
+ async_disable_stdin ();
}
if (!arg)
FIXME: Neither should "signal foo" but when I tried passing
(CORE_ADDR)-1 unconditionally I got a testsuite failure which I haven't
tried to track down yet. */
- proceed (oursig == TARGET_SIGNAL_0 ? (CORE_ADDR) - 1 : stop_pc, oursig, 0);
+ proceed (oursig == TARGET_SIGNAL_0 ? (CORE_ADDR) -1 : stop_pc, oursig, 0);
}
/* Call breakpoint_auto_delete on the current contents of the bpstat
Otherwise, run_stack-dummy returns 1 (the frame will eventually be popped
when we do hit that breakpoint). */
-/* DEBUG HOOK: 4 => return instead of letting the stack dummy run. */
-
-static int stack_dummy_testing = 0;
-
int
run_stack_dummy (addr, buffer)
CORE_ADDR addr;
/* Now proceed, having reached the desired place. */
clear_proceed_status ();
- if (stack_dummy_testing & 4)
- {
- POP_FRAME;
- return (0);
- }
+
if (CALL_DUMMY_BREAKPOINT_OFFSET_P)
{
struct breakpoint *bpt;
step_multi = 0; /* Only one call to proceed */
- proceed ((CORE_ADDR) - 1, TARGET_SIGNAL_DEFAULT, 1);
+ proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 1);
}
static void
/* If we must run in the background, but the target can't do it,
error out. */
- if (async_p && async_exec && !target_has_async)
+ 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. */
- if (async_p && !async_exec && target_has_async)
+ if (event_loop_p && !async_exec && target_can_async_p ())
{
/* Simulate synchronous execution */
- sync_execution = 1;
+ async_disable_stdin ();
}
if (arg)
}
\f
+/* 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)
+{
+ register value_ptr value;
+
+ 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");
+ }
+ else
+ {
+ /* 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;
+ printf_filtered ("Value returned has type: %s.", TYPE_NAME (value_type));
+ printf_filtered (" 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");
+#endif
+ }
+}
+
/* 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
&& function != 0)
{
struct type *value_type;
- register value_ptr val;
CORE_ADDR funcaddr;
int struct_return;
value_type = TYPE_TARGET_TYPE (SYMBOL_TYPE (function));
if (!value_type)
- fatal ("internal: finish_command: function has no target type");
+ internal_error ("finish_command: function has no target type");
if (TYPE_CODE (value_type) == TYPE_CODE_VOID)
{
funcaddr = BLOCK_START (SYMBOL_BLOCK_VALUE (function));
struct_return = using_struct_return (value_of_variable (function, NULL),
-
funcaddr,
check_typedef (value_type),
- BLOCK_GCC_COMPILED (SYMBOL_BLOCK_VALUE (function)));
-
- if (!struct_return)
- {
- val = value_being_returned (value_type, stop_registers, struct_return);
- printf_filtered ("Value returned is $%d = ", record_latest_value (val));
- value_print (val, gdb_stdout, 0, Val_no_prettyprint);
- printf_filtered ("\n");
- }
- else
- {
- /* 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
- val = 0;
- printf_filtered ("Value returned has type: %s.",
- TYPE_NAME (value_type));
- printf_filtered (" Cannot determine contents\n");
-#else
- val = value_being_returned (value_type, stop_registers,
- struct_return);
- printf_filtered ("Value returned is $%d = ",
- record_latest_value (val));
- value_print (val, gdb_stdout, 0, Val_no_prettyprint);
- printf_filtered ("\n");
-#endif
+ BLOCK_GCC_COMPILED (SYMBOL_BLOCK_VALUE (function)));
- }
+ print_return_value (struct_return, value_type);
}
do_exec_cleanups (ALL_CLEANUPS);
}
/* If we must run in the background, but the target can't do it,
error out. */
- if (async_p && async_exec && !target_has_async)
+ 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. */
- if (async_p && !async_exec && target_has_async)
+ if (event_loop_p && !async_exec && target_can_async_p ())
{
/* Simulate synchronous execution */
- sync_execution = 1;
+ async_disable_stdin ();
}
if (arg)
breakpoint = set_momentary_breakpoint (sal, frame, bp_finish);
- if (!async_p || !target_has_async)
+ if (!event_loop_p || !target_can_async_p ())
old_chain = make_cleanup ((make_cleanup_func) delete_breakpoint, breakpoint);
else
make_exec_cleanup ((make_cleanup_func) delete_breakpoint, breakpoint);
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. */
- if (async_p && target_has_async)
+ if (event_loop_p && target_can_async_p ())
{
arg1 =
(struct continuation_arg *) xmalloc (sizeof (struct continuation_arg));
}
proceed_to_finish = 1; /* We want stop_registers, please... */
- proceed ((CORE_ADDR) - 1, TARGET_SIGNAL_DEFAULT, 0);
+ 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. */
- if (!async_p || !target_has_async)
+ if (!event_loop_p || !target_can_async_p ())
{
/* Did we stop at our breakpoint? */
&& function != 0)
{
struct type *value_type;
- register value_ptr val;
CORE_ADDR funcaddr;
int struct_return;
value_type = TYPE_TARGET_TYPE (SYMBOL_TYPE (function));
if (!value_type)
- fatal ("internal: finish_command: function has no target type");
+ internal_error ("finish_command: function has no target type");
/* FIXME: Shouldn't we do the cleanups before returning? */
if (TYPE_CODE (value_type) == TYPE_CODE_VOID)
check_typedef (value_type),
BLOCK_GCC_COMPILED (SYMBOL_BLOCK_VALUE (function)));
- if (!struct_return)
- {
- val =
- value_being_returned (value_type, stop_registers, struct_return);
- printf_filtered ("Value returned is $%d = ",
- record_latest_value (val));
- value_print (val, gdb_stdout, 0, Val_no_prettyprint);
- printf_filtered ("\n");
- }
- else
- {
- /* 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
- val = 0;
- printf_filtered ("Value returned has type: %s.",
- TYPE_NAME (value_type));
- printf_filtered (" Cannot determine contents\n");
-#else
- val = value_being_returned (value_type, stop_registers,
- struct_return);
- printf_filtered ("Value returned is $%d = ",
- record_latest_value (val));
- value_print (val, gdb_stdout, 0, Val_no_prettyprint);
- printf_filtered ("\n");
-#endif
- }
+ print_return_value (struct_return, value_type);
}
do_cleanups (old_chain);
}
target_post_attach (inferior_pid);
normal_stop ();
+
+ if (attach_hook)
+ attach_hook ();
}
/*
#if defined(SOLIB_RESTART)
SOLIB_RESTART ();
#endif
+ if (detach_hook)
+ detach_hook ();
}
/* Stop the execution of the target while running in async mode, in
char *args;
int from_tty;
{
- if (async_p && target_has_async)
+ if (event_loop_p && target_can_async_p ())
{
dont_repeat (); /* Not for the faint of heart */
target_stop ();
projects / deliverable / binutils-gdb.git / blobdiff