#include "observer.h"
#include "target-descriptions.h"
#include "user-regs.h"
+#include "exceptions.h"
+#include "cli/cli-decode.h"
+#include "gdbthread.h"
/* Functions exported for general use, in inferior.h: */
static void nofp_registers_info (char *, int);
-static void print_return_value (struct type *value_type);
-
-static void finish_command_continuation (struct continuation_arg *);
+static void print_return_value (struct type *func_type,
+ struct type *value_type);
static void until_next_command (int);
static void jump_command (char *, int);
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);
+static void step_once (int skip_subroutines, int single_inst, int count, int thread);
static void next_command (char *, int);
in format described in environ.h. */
struct gdb_environ *inferior_environ;
+
+/* When set, no calls to target_resumed observer will be made. */
+int suppress_resume_observer = 0;
+/* When set, normal_stop will not call the normal_stop observer. */
+int suppress_stop_observer = 0;
\f
/* Accessor routines. */
notice_args_read (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
{
- deprecated_show_value_hack (file, from_tty, c, value);
- /* Might compute the value. */
- get_inferior_args ();
+ /* Note that we ignore the passed-in value in favor of computing it
+ directly. */
+ deprecated_show_value_hack (file, from_tty, c, get_inferior_args ());
}
\f
from the beginning. Ask the user to confirm that he wants to restart
the program being debugged when FROM_TTY is non-null. */
-void
+static void
kill_if_already_running (int from_tty)
{
if (! ptid_equal (inferior_ptid, null_ptid) && target_has_execution)
{
+ /* Bail out before killing the program if we will not be able to
+ restart it. */
+ target_require_runnable ();
+
if (from_tty
&& !query ("The program being debugged has been started already.\n\
Start it from the beginning? "))
error (_("Program not restarted."));
target_kill ();
-#if defined(SOLIB_RESTART)
- SOLIB_RESTART ();
-#endif
+ no_shared_libraries (NULL, from_tty);
init_wait_for_inferior ();
}
}
run_command_1 (args, from_tty, 1);
}
+static int
+proceed_thread_callback (struct thread_info *thread, void *arg)
+{
+ if (!is_stopped (thread->ptid))
+ return 0;
+
+ context_switch_to (thread->ptid);
+ clear_proceed_status ();
+ proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 0);
+ return 0;
+}
+
void
-continue_command (char *proc_count_exp, int from_tty)
+continue_1 (int all_threads)
+{
+ if (non_stop && all_threads)
+ {
+ /* Don't error out if the current thread is running, because
+ there may be other stopped threads. */
+ struct cleanup *old_chain;
+
+ /* Backup current thread and selected frame. */
+ old_chain = make_cleanup_restore_current_thread ();
+
+ iterate_over_threads (proceed_thread_callback, NULL);
+
+ /* Restore selected ptid. */
+ do_cleanups (old_chain);
+ }
+ else
+ {
+ ensure_not_running ();
+ clear_proceed_status ();
+ proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 0);
+ }
+}
+
+/* continue [-a] [proceed-count] [&] */
+void
+continue_command (char *args, int from_tty)
{
int async_exec = 0;
+ int all_threads = 0;
ERROR_NO_INFERIOR;
/* Find out whether we must run in the background. */
- if (proc_count_exp != NULL)
- async_exec = strip_bg_char (&proc_count_exp);
+ if (args != NULL)
+ async_exec = strip_bg_char (&args);
/* If we must run in the background, but the target can't do it,
error out. */
async_disable_stdin ();
}
- /* If have argument (besides '&'), set proceed count of breakpoint
- we stopped at. */
- if (proc_count_exp != NULL)
+ if (args != NULL)
+ {
+ if (strncmp (args, "-a", sizeof ("-a") - 1) == 0)
+ {
+ all_threads = 1;
+ args += sizeof ("-a") - 1;
+ if (*args == '\0')
+ args = NULL;
+ }
+ }
+
+ if (!non_stop && all_threads)
+ error (_("`-a' is meaningless in all-stop mode."));
+
+ if (args != NULL && all_threads)
+ error (_("\
+Can't resume all threads and specify proceed count simultaneously."));
+
+ /* If we have an argument left, set proceed count of breakpoint we
+ stopped at. */
+ if (args != NULL)
{
bpstat bs = stop_bpstat;
int num, stat;
if (stat > 0)
{
set_ignore_count (num,
- parse_and_eval_long (proc_count_exp) - 1,
+ parse_and_eval_long (args) - 1,
from_tty);
/* set_ignore_count prints a message ending with a period.
So print two spaces before "Continuing.". */
if (from_tty)
printf_filtered (_("Continuing.\n"));
- clear_proceed_status ();
-
- proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 0);
+ continue_1 (all_threads);
}
\f
/* Step until outside of current statement. */
}
static void
-disable_longjmp_breakpoint_cleanup (void *ignore)
+delete_longjmp_breakpoint_cleanup (void *arg)
{
- disable_longjmp_breakpoint ();
+ int thread = * (int *) arg;
+ delete_longjmp_breakpoint (thread);
}
static void
{
int count = 1;
struct frame_info *frame;
- struct cleanup *cleanups = 0;
+ struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
int async_exec = 0;
+ int thread = -1;
ERROR_NO_INFERIOR;
+ ensure_not_running ();
if (count_string)
async_exec = strip_bg_char (&count_string);
if (!single_inst || skip_subroutines) /* leave si command alone */
{
- enable_longjmp_breakpoint ();
- if (!target_can_async_p ())
- cleanups = make_cleanup (disable_longjmp_breakpoint_cleanup, 0 /*ignore*/);
- else
- make_exec_cleanup (disable_longjmp_breakpoint_cleanup, 0 /*ignore*/);
+ if (in_thread_list (inferior_ptid))
+ thread = pid_to_thread_id (inferior_ptid);
+
+ set_longjmp_breakpoint ();
+
+ make_cleanup (delete_longjmp_breakpoint_cleanup, &thread);
}
/* In synchronous case, all is well, just use the regular for loop. */
break;
}
- if (!single_inst || skip_subroutines)
- do_cleanups (cleanups);
+ do_cleanups (cleanups);
return;
}
/* In case of asynchronous target things get complicated, do only
and handle them one at the time, through step_once(). */
else
{
- if (target_can_async_p ())
- step_once (skip_subroutines, single_inst, count);
+ step_once (skip_subroutines, single_inst, count, thread);
+ /* We are running, and the continuation is installed. It will
+ disable the longjmp breakpoint as appropriate. */
+ discard_cleanups (cleanups);
}
}
+struct step_1_continuation_args
+{
+ int count;
+ int skip_subroutines;
+ int single_inst;
+ int thread;
+};
+
/* 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 (struct continuation_arg *arg)
+step_1_continuation (void *args)
{
- 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;
+ struct step_1_continuation_args *a = args;
- if (stop_step)
- step_once (skip_subroutines, single_inst, count - 1);
+ if (!step_multi || !stop_step)
+ {
+ /* If we stopped for some reason that is not stepping there are
+ no further steps to make. Cleanup. */
+ if (!a->single_inst || a->skip_subroutines)
+ delete_longjmp_breakpoint (a->thread);
+ step_multi = 0;
+ }
else
- if (!single_inst || skip_subroutines)
- do_exec_cleanups (ALL_CLEANUPS);
+ step_once (a->skip_subroutines, a->single_inst, a->count - 1, a->thread);
}
/* 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)
-{
- struct continuation_arg *arg1;
- struct continuation_arg *arg2;
- struct continuation_arg *arg3;
+step_once (int skip_subroutines, int single_inst, int count, int thread)
+{
struct frame_info *frame;
+ struct step_1_continuation_args *args;
if (count > 0)
{
step_over_calls = STEP_OVER_ALL;
step_multi = (count > 1);
- 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.integer = skip_subroutines;
- arg2->next = arg3;
- arg2->data.integer = single_inst;
- arg3->next = NULL;
- arg3->data.integer = count;
- add_intermediate_continuation (step_1_continuation, arg1);
proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 1);
+
+ args = xmalloc (sizeof (*args));
+ args->skip_subroutines = skip_subroutines;
+ args->single_inst = single_inst;
+ args->count = count;
+ args->thread = thread;
+ add_intermediate_continuation (step_1_continuation, args, xfree);
}
}
int async_exec = 0;
ERROR_NO_INFERIOR;
+ ensure_not_running ();
/* Find out whether we must run in the background. */
if (arg != NULL)
if (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_exec && target_can_async_p ())
- {
- /* Simulate synchronous execution */
- async_disable_stdin ();
- }
-
if (!arg)
error_no_arg (_("starting address"));
printf_filtered (".\n");
}
+ /* If we are not asked to run in the bg, then prepare to run in the
+ foreground, synchronously. */
+ if (!async_exec && target_can_async_p ())
+ {
+ /* Simulate synchronous execution */
+ async_disable_stdin ();
+ }
+
clear_proceed_status ();
proceed (addr, TARGET_SIGNAL_0, 0);
}
signal_command (char *signum_exp, int from_tty)
{
enum target_signal oursig;
+ int async_exec = 0;
dont_repeat (); /* Too dangerous. */
ERROR_NO_INFERIOR;
+ ensure_not_running ();
+
+ /* Find out whether we must run in the background. */
+ if (signum_exp != NULL)
+ async_exec = strip_bg_char (&signum_exp);
+
+ /* If we must run in the background, but the target can't do it,
+ error out. */
+ if (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_exec && target_can_async_p ())
+ {
+ /* Simulate synchronous execution. */
+ async_disable_stdin ();
+ }
if (!signum_exp)
error_no_arg (_("signal number"));
/* Print the result of a function at the end of a 'finish' command. */
static void
-print_return_value (struct type *value_type)
+print_return_value (struct type *func_type, struct type *value_type)
{
struct gdbarch *gdbarch = current_gdbarch;
struct cleanup *old_chain;
inferior function call code. In fact, when inferior function
calls are made async, this will likely be made the norm. */
- switch (gdbarch_return_value (gdbarch, value_type, NULL, NULL, NULL))
+ switch (gdbarch_return_value (gdbarch, func_type, value_type,
+ NULL, NULL, NULL))
{
case RETURN_VALUE_REGISTER_CONVENTION:
case RETURN_VALUE_ABI_RETURNS_ADDRESS:
case RETURN_VALUE_ABI_PRESERVES_ADDRESS:
value = allocate_value (value_type);
- gdbarch_return_value (gdbarch, value_type, stop_registers,
+ gdbarch_return_value (gdbarch, func_type, value_type, stop_registers,
value_contents_raw (value), NULL);
break;
case RETURN_VALUE_STRUCT_CONVENTION:
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 finish_command_continuation_args
{
- struct symbol *function;
struct breakpoint *breakpoint;
- struct cleanup *cleanups;
+ struct symbol *function;
+};
- breakpoint = (struct breakpoint *) arg->data.pointer;
- function = (struct symbol *) arg->next->data.pointer;
- cleanups = (struct cleanup *) arg->next->next->data.pointer;
+static void
+finish_command_continuation (void *arg)
+{
+ struct finish_command_continuation_args *a = arg;
- if (bpstat_find_breakpoint (stop_bpstat, breakpoint) != NULL
- && function != NULL)
+ if (bpstat_find_breakpoint (stop_bpstat, a->breakpoint) != NULL
+ && a->function != NULL)
{
struct type *value_type;
- value_type = TYPE_TARGET_TYPE (SYMBOL_TYPE (function));
+ value_type = TYPE_TARGET_TYPE (SYMBOL_TYPE (a->function));
if (!value_type)
internal_error (__FILE__, __LINE__,
_("finish_command: function has no target type"));
if (TYPE_CODE (value_type) != TYPE_CODE_VOID)
- print_return_value (value_type);
+ print_return_value (SYMBOL_TYPE (a->function), value_type);
}
- do_exec_cleanups (cleanups);
+ /* We suppress normal call of normal_stop observer and do it here so
+ that that *stopped notification includes the return value. */
+ /* NOTE: This is broken in non-stop mode. There is no guarantee the
+ next stop will be in the same thread that we started doing a
+ finish on. This suppressing (or some other replacement means)
+ should be a thread property. */
+ observer_notify_normal_stop (stop_bpstat);
+ suppress_stop_observer = 0;
+ delete_breakpoint (a->breakpoint);
+}
+
+static void
+finish_command_continuation_free_arg (void *arg)
+{
+ /* NOTE: See finish_command_continuation. This would go away, if
+ this suppressing is made a thread property. */
+ suppress_stop_observer = 0;
+ xfree (arg);
}
/* "finish": Set a temporary breakpoint at the place the selected
struct symbol *function;
struct breakpoint *breakpoint;
struct cleanup *old_chain;
- struct continuation_arg *arg1, *arg2, *arg3;
+ struct finish_command_continuation_args *cargs;
int async_exec = 0;
breakpoint = set_momentary_breakpoint (sal, get_frame_id (frame), bp_finish);
- if (!target_can_async_p ())
- old_chain = make_cleanup_delete_breakpoint (breakpoint);
- else
- old_chain = make_exec_cleanup_delete_breakpoint (breakpoint);
+ old_chain = make_cleanup_delete_breakpoint (breakpoint);
/* Find the function we will return from. */
print_stack_frame (get_selected_frame (NULL), 1, LOCATION);
}
- /* 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. */
- if (target_can_async_p ())
- {
- 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;
- 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);
- }
-
proceed_to_finish = 1; /* We want stop_registers, please... */
+ make_cleanup_restore_integer (&suppress_stop_observer);
+ suppress_stop_observer = 1;
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 (!target_can_async_p ())
- {
- /* Did we stop at our breakpoint? */
- if (bpstat_find_breakpoint (stop_bpstat, breakpoint) != NULL
- && function != NULL)
- {
- struct type *value_type;
+ cargs = xmalloc (sizeof (*cargs));
- value_type = TYPE_TARGET_TYPE (SYMBOL_TYPE (function));
- if (!value_type)
- internal_error (__FILE__, __LINE__,
- _("finish_command: function has no target type"));
+ cargs->breakpoint = breakpoint;
+ cargs->function = function;
+ add_continuation (finish_command_continuation, cargs,
+ finish_command_continuation_free_arg);
- if (TYPE_CODE (value_type) != TYPE_CODE_VOID)
- print_return_value (value_type);
- }
-
- do_cleanups (old_chain);
- }
+ discard_cleanups (old_chain);
+ if (!target_can_async_p ())
+ do_all_continuations ();
}
\f
/* If virtual format is floating, print it that way, and in raw
hex. */
- if (TYPE_CODE (register_type (gdbarch, i)) == TYPE_CODE_FLT)
+ if (TYPE_CODE (register_type (gdbarch, i)) == TYPE_CODE_FLT
+ || TYPE_CODE (register_type (gdbarch, i)) == TYPE_CODE_DECFLOAT)
{
int j;
val_print (register_type (gdbarch, i), buffer, 0, 0,
- file, 0, 1, 0, Val_pretty_default);
+ file, 0, 1, 0, Val_pretty_default, current_language);
fprintf_filtered (file, "\t(raw 0x");
for (j = 0; j < register_size (gdbarch, i); j++)
{
/* Print the register in hex. */
val_print (register_type (gdbarch, i), buffer, 0, 0,
- file, 'x', 1, 0, Val_pretty_default);
+ file, 'x', 1, 0, Val_pretty_default, current_language);
/* If not a vector register, print it also according to its
natural format. */
if (TYPE_VECTOR (register_type (gdbarch, i)) == 0)
{
fprintf_filtered (file, "\t");
val_print (register_type (gdbarch, i), buffer, 0, 0,
- file, 0, 1, 0, Val_pretty_default);
+ file, 0, 1, 0, Val_pretty_default, current_language);
}
}
This stops it cold in its tracks and allows us to start debugging it.
and wait for the trace-trap that results from attaching. */
+static void
+attach_command_post_wait (char *args, int from_tty, int async_exec)
+{
+ char *exec_file;
+ char *full_exec_path = NULL;
+
+ stop_soon = NO_STOP_QUIETLY;
+
+ /* If no exec file is yet known, try to determine it from the
+ process itself. */
+ exec_file = (char *) get_exec_file (0);
+ if (!exec_file)
+ {
+ exec_file = target_pid_to_exec_file (PIDGET (inferior_ptid));
+ if (exec_file)
+ {
+ /* It's possible we don't have a full path, but rather just a
+ filename. Some targets, such as HP-UX, don't provide the
+ full path, sigh.
+
+ Attempt to qualify the filename against the source path.
+ (If that fails, we'll just fall back on the original
+ filename. Not much more we can do...)
+ */
+ if (!source_full_path_of (exec_file, &full_exec_path))
+ full_exec_path = savestring (exec_file, strlen (exec_file));
+
+ exec_file_attach (full_exec_path, from_tty);
+ symbol_file_add_main (full_exec_path, from_tty);
+ }
+ }
+ else
+ {
+ reopen_exec_file ();
+ reread_symbols ();
+ }
+
+ /* Take any necessary post-attaching actions for this platform. */
+ target_post_attach (PIDGET (inferior_ptid));
+
+ post_create_inferior (¤t_target, from_tty);
+
+ /* Install inferior's terminal modes. */
+ target_terminal_inferior ();
+
+ if (async_exec)
+ proceed ((CORE_ADDR) -1, TARGET_SIGNAL_0, 0);
+ else
+ {
+ if (target_can_async_p ())
+ async_enable_stdin ();
+ normal_stop ();
+ if (deprecated_attach_hook)
+ deprecated_attach_hook ();
+ }
+}
+
+struct attach_command_continuation_args
+{
+ char *args;
+ int from_tty;
+ int async_exec;
+};
+
+static void
+attach_command_continuation (void *args)
+{
+ struct attach_command_continuation_args *a = args;
+ attach_command_post_wait (a->args, a->from_tty, a->async_exec);
+}
+
+static void
+attach_command_continuation_free_args (void *args)
+{
+ struct attach_command_continuation_args *a = args;
+ xfree (a->args);
+ xfree (a);
+}
+
void
attach_command (char *args, int from_tty)
{
char *exec_file;
char *full_exec_path = NULL;
+ int async_exec = 0;
dont_repeat (); /* Not for the faint of heart */
*/
clear_solib ();
+ if (args)
+ {
+ async_exec = strip_bg_char (&args);
+
+ /* If we get a request for running in the bg but the target
+ doesn't support it, error out. */
+ if (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_exec && target_can_async_p ())
+ {
+ /* Simulate synchronous execution */
+ async_disable_stdin ();
+ }
+
target_attach (args, from_tty);
/* Set up the "saved terminal modes" of the inferior
init_wait_for_inferior ();
clear_proceed_status ();
- /* No traps are generated when attaching to inferior under Mach 3
- or GNU hurd. */
-#ifndef ATTACH_NO_WAIT
- /* Careful here. See comments in inferior.h. Basically some OSes
- don't ignore SIGSTOPs on continue requests anymore. We need a
- way for handle_inferior_event to reset the stop_signal variable
- after an attach, and this is what STOP_QUIETLY_NO_SIGSTOP is for. */
- stop_soon = STOP_QUIETLY_NO_SIGSTOP;
- wait_for_inferior (0);
- stop_soon = NO_STOP_QUIETLY;
-#endif
-
- /*
- * If no exec file is yet known, try to determine it from the
- * process itself.
- */
- exec_file = (char *) get_exec_file (0);
- if (!exec_file)
+ /* Some system don't generate traps when attaching to inferior.
+ E.g. Mach 3 or GNU hurd. */
+ if (!target_attach_no_wait)
{
- exec_file = target_pid_to_exec_file (PIDGET (inferior_ptid));
- if (exec_file)
- {
- /* It's possible we don't have a full path, but rather just a
- filename. Some targets, such as HP-UX, don't provide the
- full path, sigh.
-
- Attempt to qualify the filename against the source path.
- (If that fails, we'll just fall back on the original
- filename. Not much more we can do...)
- */
- if (!source_full_path_of (exec_file, &full_exec_path))
- full_exec_path = savestring (exec_file, strlen (exec_file));
+ /* Careful here. See comments in inferior.h. Basically some
+ OSes don't ignore SIGSTOPs on continue requests anymore. We
+ need a way for handle_inferior_event to reset the stop_signal
+ variable after an attach, and this is what
+ STOP_QUIETLY_NO_SIGSTOP is for. */
+ stop_soon = STOP_QUIETLY_NO_SIGSTOP;
- exec_file_attach (full_exec_path, from_tty);
- symbol_file_add_main (full_exec_path, from_tty);
+ if (target_can_async_p ())
+ {
+ /* sync_execution mode. Wait for stop. */
+ struct attach_command_continuation_args *a;
+
+ a = xmalloc (sizeof (*a));
+ a->args = xstrdup (args);
+ a->from_tty = from_tty;
+ a->async_exec = async_exec;
+ add_continuation (attach_command_continuation, a,
+ attach_command_continuation_free_args);
+ return;
}
- }
- else
- {
- reopen_exec_file ();
- reread_symbols ();
- }
-
- /* Take any necessary post-attaching actions for this platform.
- */
- target_post_attach (PIDGET (inferior_ptid));
- post_create_inferior (¤t_target, from_tty);
-
- /* Install inferior's terminal modes. */
- target_terminal_inferior ();
-
- normal_stop ();
+ wait_for_inferior (0);
+ }
- if (deprecated_attach_hook)
- deprecated_attach_hook ();
+ attach_command_post_wait (args, from_tty, async_exec);
}
/*
{
dont_repeat (); /* Not for the faint of heart. */
target_detach (args, from_tty);
-#if defined(SOLIB_RESTART)
- SOLIB_RESTART ();
-#endif
+ no_shared_libraries (NULL, from_tty);
+ init_thread_list ();
if (deprecated_detach_hook)
deprecated_detach_hook ();
}
{
dont_repeat (); /* Not for the faint of heart */
target_disconnect (args, from_tty);
-#if defined(SOLIB_RESTART)
- SOLIB_RESTART ();
-#endif
+ no_shared_libraries (NULL, from_tty);
+ init_thread_list ();
if (deprecated_detach_hook)
deprecated_detach_hook ();
}
+void
+interrupt_target_1 (int all_threads)
+{
+ ptid_t ptid;
+ if (all_threads)
+ ptid = minus_one_ptid;
+ else
+ ptid = inferior_ptid;
+ target_stop (ptid);
+}
+
/* Stop the execution of the target while running in async mode, in
- the backgound. */
+ the backgound. In all-stop, stop the whole process. In non-stop
+ mode, stop the current thread only by default, or stop all threads
+ if the `-a' switch is used. */
+
+/* interrupt [-a] */
void
interrupt_target_command (char *args, int from_tty)
{
if (target_can_async_p ())
{
+ int all_threads = 0;
+
dont_repeat (); /* Not for the faint of heart */
- target_stop ();
+
+ if (args != NULL
+ && strncmp (args, "-a", sizeof ("-a") - 1) == 0)
+ all_threads = 1;
+
+ if (!non_stop && all_threads)
+ error (_("-a is meaningless in all-stop mode."));
+
+ interrupt_target_1 (all_threads);
}
}
add_com ("finish", class_run, finish_command, _("\
Execute until selected stack frame returns.\n\
Upon return, the value returned is printed and put in the value history."));
+ add_com_alias ("fin", "finish", class_run, 1);
add_com ("next", class_run, next_command, _("\
Step program, proceeding through subroutine calls.\n\
if (xdb_commands)
add_com_alias ("g", "go", class_run, 1);
- add_com ("continue", class_run, continue_command, _("\
+ c = add_com ("continue", class_run, continue_command, _("\
Continue program being debugged, after signal or breakpoint.\n\
If proceeding from breakpoint, a number N may be used as an argument,\n\
which means to set the ignore count of that breakpoint to N - 1 (so that\n\
-the breakpoint won't break until the Nth time it is reached)."));
+the breakpoint won't break until the Nth time it is reached).\n\
+\n\
+If non-stop mode is enabled, continue only the current thread,\n\
+otherwise all the threads in the program are continued. To \n\
+continue all stopped threads in non-stop mode, use the -a option.\n\
+Specifying -a and an ignore count simultaneously is an error."));
add_com_alias ("c", "cont", class_run, 1);
add_com_alias ("fg", "cont", class_run, 1);
+ set_cmd_async_ok (c);
c = add_com ("run", class_run, run_command, _("\
Start debugged program. You may specify arguments to give it.\n\
\"run\" command."));
set_cmd_completer (c, filename_completer);
- add_com ("interrupt", class_run, interrupt_target_command,
- _("Interrupt the execution of the debugged program."));
+ c = add_com ("interrupt", class_run, interrupt_target_command,
+ _("Interrupt the execution of the debugged program.\n\
+If non-stop mode is enabled, interrupt only the current thread,\n\
+otherwise all the threads in the program are stopped. To \n\
+interrupt all running threads in non-stop mode, use the -a option."));
+ set_cmd_async_ok (c);
add_info ("registers", nofp_registers_info, _("\
List of integer registers and their contents, for selected stack frame.\n\
projects / deliverable / binutils-gdb.git / blobdiff