summaryrefslogtreecommitdiff
path: root/gdb
diff options
context:
space:
mode:
authorPedro Alves <pedro@codesourcery.com>2008-07-11 11:07:39 +0000
committerPedro Alves <pedro@codesourcery.com>2008-07-11 11:07:39 +0000
commit7c5acce6a59f638524b4b63325cf45ce6b83bd04 (patch)
treeecfb4396a5e45a1a96b4de299c37490e33f5e71b /gdb
parentb20ba145c2cd2c5af118cb64371c8f3c35fabc86 (diff)
downloadgdb-7c5acce6a59f638524b4b63325cf45ce6b83bd04.tar.gz
Exited threads.
* thread.c (enum thread_state): New. (thread_state main_thread_running): Delete, in favor of... (thread_state main_thread_state): ... this. Update throughout. (clear_thread_inferior_resources): New, split from free_thread. (free_thread): Call clear_thread_inferior_resources. (init_thread_list): Set main thread to stopped state. (add_thread_silent): Take care of PTID reuses. (delete_thread): If deleting inferior_ptid or a thread with refcount > 0, mark it as exited, but still keep it in the list. Only notify of thread exits, if we haven't done so yet. (iterate_over_threads): Make it safe to delete threads while iterating over them. (do_captured_list_thread_ids): Don't account for exited threads. (thread_alive): Check for the THREAD_EXITED state, and don't set ptid to -1 on exited threads. (set_running): Update to account for extra possible states. (is_thread_state): New. (is_stopped, is_exited): New. (is_running): Implement in terms of is_thread_state. (any_running): Update. (print_thread_info): Update. Account for exited threads. Don't warn about missed frame restoring here, its done in the cleanup. (switch_to_thread): Don't read from a thread that has gone. (restore_current_thread): In non-stop mode, do a full context switch. (restore_selected_frame): Add a frame_level argument. Rewrite. (struct current_thread_cleanup): Add selected_frame_level and was_stopped members. (do_restore_current_thread_cleanup): Check if thread was stopped and still is, and if the target has registers, stack and memory before restoring the selected frame. Don't delete the cleanup argument here. (restore_current_thread_cleanup_dtor): New. (make_cleanup_restore_current_thread): Remove all arguments. Rewrite. (thread_apply_all_command): Update. Prune threads. (thread_apply_command): Update. (thread_command): Account for currently selected exited thread. (do_captured_thread_select): Check for a running thread. Prune threads. (_initialize_thread): Make "info threads", "thread", "thread apply", and "thread apply all" appliable without a selected thread. * gdbthread.h (struct thread_info): Replace running_ by state_. Add refcount. (is_exited, is_stopped): Declare. (make_cleanup_restore_current_thread): Remove all arguments. * infrun.c: Include "event-top.h". (fetch_inferior_event): In non-stop mode, restore selected thread and frame after handling the event and running breakpoint commands. Display GDB prompt if needed. (normal_stop): In non-stop mode, don't print thread switching notice. * cli/cli-decode.c (set_cmd_no_selected_thread_ok) (get_cmd_no_selected_thread_ok): New. * cli/cli-decode.h (CMD_NO_SELECTED_THREAD_OK): New. (set_cmd_no_selected_thread_ok, get_cmd_no_selected_thread_ok): Declare. * cli/cli-cmds.c: Set "pwd", "help", "info", "show" as no-selected-thread ok. * top.c (execute_command): Check for non no-selected-thread-ok commands. * linux-nat.c (struct saved_ptids, threads_to_delete) (record_dead_thread, prune_lwps): Delete. (exit_lwp): Unconditionally delete thread. (linux_nat_resume): Remove prune_lwps call. * infcmd.c (proceed_thread_callback): Check if !is_stopped instead of is_running. Adjust to make_cleanup_restore_current_thread interface change. * mi/mi-main.c (mi_cmd_execute): Only allow a few commands if the selected thread has exited. * inf-loop.c (inferior_event_handler): Don't display the prompt here. * varobj.c (c_value_of_root): Update. * defs.h (make_cleanup_dtor): Declare. * utils.c (make_cleanup_dtor): New. * Makefile.in (infrun.o): Depend on $(event_top_h).
Diffstat (limited to 'gdb')
-rw-r--r--gdb/ChangeLog82
-rw-r--r--gdb/Makefile.in2
-rw-r--r--gdb/cli/cli-cmds.c5
-rw-r--r--gdb/cli/cli-decode.c12
-rw-r--r--gdb/cli/cli-decode.h11
-rw-r--r--gdb/defs.h3
-rw-r--r--gdb/gdbthread.h30
-rw-r--r--gdb/inf-loop.c16
-rw-r--r--gdb/infcmd.c12
-rw-r--r--gdb/infrun.c26
-rw-r--r--gdb/linux-nat.c48
-rw-r--r--gdb/mi/mi-main.c18
-rw-r--r--gdb/thread.c467
-rw-r--r--gdb/top.c19
-rw-r--r--gdb/utils.c8
-rw-r--r--gdb/varobj.c3
16 files changed, 536 insertions, 226 deletions
diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index df5cd3db2b5..4c5de4987fd 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,5 +1,87 @@
2008-07-11 Pedro Alves <pedro@codesourcery.com>
+ Exited threads.
+
+ * thread.c (enum thread_state): New.
+ (thread_state main_thread_running): Delete, in favor of...
+ (thread_state main_thread_state): ... this. Update throughout.
+ (clear_thread_inferior_resources): New, split from free_thread.
+ (free_thread): Call clear_thread_inferior_resources.
+ (init_thread_list): Set main thread to stopped state.
+ (add_thread_silent): Take care of PTID reuses.
+ (delete_thread): If deleting inferior_ptid or a thread with
+ refcount > 0, mark it as exited, but still keep it in the list.
+ Only notify of thread exits, if we haven't done so yet.
+ (iterate_over_threads): Make it safe to delete threads while
+ iterating over them.
+ (do_captured_list_thread_ids): Don't account for exited threads.
+ (thread_alive): Check for the THREAD_EXITED state, and don't set
+ ptid to -1 on exited threads.
+ (set_running): Update to account for extra possible states.
+ (is_thread_state): New.
+ (is_stopped, is_exited): New.
+ (is_running): Implement in terms of is_thread_state.
+ (any_running): Update.
+ (print_thread_info): Update. Account for exited threads. Don't
+ warn about missed frame restoring here, its done in the cleanup.
+ (switch_to_thread): Don't read from a thread that has gone.
+ (restore_current_thread): In non-stop mode, do a full context
+ switch.
+ (restore_selected_frame): Add a frame_level argument. Rewrite.
+ (struct current_thread_cleanup): Add selected_frame_level and
+ was_stopped members.
+ (do_restore_current_thread_cleanup): Check if thread was stopped
+ and still is, and if the target has registers, stack and memory
+ before restoring the selected frame. Don't delete the cleanup
+ argument here.
+ (restore_current_thread_cleanup_dtor): New.
+ (make_cleanup_restore_current_thread): Remove all arguments.
+ Rewrite.
+ (thread_apply_all_command): Update. Prune threads.
+ (thread_apply_command): Update.
+ (thread_command): Account for currently selected exited thread.
+ (do_captured_thread_select): Check for a running thread. Prune
+ threads.
+ (_initialize_thread): Make "info threads", "thread", "thread
+ apply", and "thread apply all" appliable without a selected thread.
+ * gdbthread.h (struct thread_info): Replace running_ by state_.
+ Add refcount.
+ (is_exited, is_stopped): Declare.
+ (make_cleanup_restore_current_thread): Remove all arguments.
+ * infrun.c: Include "event-top.h".
+ (fetch_inferior_event): In non-stop mode, restore selected thread
+ and frame after handling the event and running breakpoint
+ commands. Display GDB prompt if needed.
+ (normal_stop): In non-stop mode, don't print thread switching
+ notice.
+ * cli/cli-decode.c (set_cmd_no_selected_thread_ok)
+ (get_cmd_no_selected_thread_ok): New.
+ * cli/cli-decode.h (CMD_NO_SELECTED_THREAD_OK): New.
+ (set_cmd_no_selected_thread_ok, get_cmd_no_selected_thread_ok):
+ Declare.
+ * cli/cli-cmds.c: Set "pwd", "help", "info", "show" as
+ no-selected-thread ok.
+ * top.c (execute_command): Check for non no-selected-thread-ok
+ commands.
+ * linux-nat.c (struct saved_ptids, threads_to_delete)
+ (record_dead_thread, prune_lwps): Delete.
+ (exit_lwp): Unconditionally delete thread.
+ (linux_nat_resume): Remove prune_lwps call.
+ * infcmd.c (proceed_thread_callback): Check if !is_stopped instead
+ of is_running. Adjust to make_cleanup_restore_current_thread
+ interface change.
+ * mi/mi-main.c (mi_cmd_execute): Only allow a few commands if the
+ selected thread has exited.
+ * inf-loop.c (inferior_event_handler): Don't display the prompt
+ here.
+ * varobj.c (c_value_of_root): Update.
+ * defs.h (make_cleanup_dtor): Declare.
+ * utils.c (make_cleanup_dtor): New.
+
+ * Makefile.in (infrun.o): Depend on $(event_top_h).
+
+2008-07-11 Pedro Alves <pedro@codesourcery.com>
+
Add "continue -a" and "interrupt -a" options for non-stop mode.
* infcmd.c (proceed_thread_callback, do_context_switch_to): New.
diff --git a/gdb/Makefile.in b/gdb/Makefile.in
index efa18ea1622..7ae842093f0 100644
--- a/gdb/Makefile.in
+++ b/gdb/Makefile.in
@@ -2335,7 +2335,7 @@ infrun.o: infrun.c $(defs_h) $(gdb_string_h) $(symtab_h) $(frame_h) \
$(gdbcore_h) $(gdbcmd_h) $(cli_script_h) $(target_h) $(gdbthread_h) \
$(annotate_h) $(symfile_h) $(top_h) $(inf_loop_h) $(regcache_h) \
$(value_h) $(observer_h) $(language_h) $(solib_h) $(gdb_assert_h) \
- $(mi_common_h) $(main_h)
+ $(mi_common_h) $(main_h) $(event_top_h)
inf-ttrace.o: inf-ttrace.c $(defs_h) $(command_h) $(gdbcore_h) \
$(gdbthread_h) $(inferior_h) $(target_h) \
$(gdb_assert_h) $(gdb_string_h) $(inf_child_h) $(inf_ttrace_h)
diff --git a/gdb/cli/cli-cmds.c b/gdb/cli/cli-cmds.c
index b0f5fa0a892..efd31376e54 100644
--- a/gdb/cli/cli-cmds.c
+++ b/gdb/cli/cli-cmds.c
@@ -1245,6 +1245,8 @@ The commands below can be used to select other frames by number or address."),
c = add_com ("pwd", class_files, pwd_command, _("\
Print working directory. This is used for your program as well."));
set_cmd_async_ok (c);
+ set_cmd_no_selected_thread_ok (c);
+
c = add_cmd ("cd", class_files, cd_command, _("\
Set working directory to DIR for debugger and program being debugged.\n\
The change does not take effect for the program being debugged\n\
@@ -1285,6 +1287,7 @@ when GDB is started."), gdbinit);
_("Print list of commands."));
set_cmd_completer (c, command_completer);
set_cmd_async_ok (c);
+ set_cmd_no_selected_thread_ok (c);
add_com_alias ("q", "quit", class_support, 1);
add_com_alias ("h", "help", class_support, 1);
@@ -1314,6 +1317,7 @@ Without an argument, history expansion is enabled."),
Generic command for showing things about the program being debugged."),
&infolist, "info ", 0, &cmdlist);
set_cmd_async_ok (c);
+ set_cmd_no_selected_thread_ok (c);
add_com_alias ("i", "info", class_info, 1);
add_com ("complete", class_obscure, complete_command,
@@ -1323,6 +1327,7 @@ Generic command for showing things about the program being debugged."),
Generic command for showing things about the debugger."),
&showlist, "show ", 0, &cmdlist);
set_cmd_async_ok (c);
+ set_cmd_no_selected_thread_ok (c);
/* Another way to get at the same thing. */
add_info ("set", show_command, _("Show all GDB settings."));
diff --git a/gdb/cli/cli-decode.c b/gdb/cli/cli-decode.c
index 05a0b27cea5..07bb5878e2a 100644
--- a/gdb/cli/cli-decode.c
+++ b/gdb/cli/cli-decode.c
@@ -117,6 +117,18 @@ get_cmd_async_ok (struct cmd_list_element *cmd)
return cmd->flags & CMD_ASYNC_OK;
}
+void
+set_cmd_no_selected_thread_ok (struct cmd_list_element *cmd)
+{
+ cmd->flags |= CMD_NO_SELECTED_THREAD_OK;
+}
+
+int
+get_cmd_no_selected_thread_ok (struct cmd_list_element *cmd)
+{
+ return cmd->flags & CMD_NO_SELECTED_THREAD_OK;
+}
+
enum cmd_types
cmd_type (struct cmd_list_element *cmd)
{
diff --git a/gdb/cli/cli-decode.h b/gdb/cli/cli-decode.h
index f133b3d8fe0..c7903984f63 100644
--- a/gdb/cli/cli-decode.h
+++ b/gdb/cli/cli-decode.h
@@ -51,6 +51,10 @@ cmd_types;
/* This flag is set if the command is allowed during async execution. */
#define CMD_ASYNC_OK 0x8
+/* This flag is set if the command is allowed to run when the target
+ has execution, but there's no selected thread. */
+#define CMD_NO_SELECTED_THREAD_OK 0x10
+
struct cmd_list_element
{
/* Points to next command in this list. */
@@ -253,6 +257,13 @@ extern void set_cmd_async_ok (struct cmd_list_element *);
/* Return true if command is async-ok. */
extern int get_cmd_async_ok (struct cmd_list_element *);
+/* Mark command as ok to call when there is no selected thread. There
+ is no way to disable this once set. */
+extern void set_cmd_no_selected_thread_ok (struct cmd_list_element *);
+
+/* Return true if command is no-selected-thread-ok. */
+extern int get_cmd_no_selected_thread_ok (struct cmd_list_element *);
+
extern struct cmd_list_element *lookup_cmd (char **,
struct cmd_list_element *, char *,
int, int);
diff --git a/gdb/defs.h b/gdb/defs.h
index 2195ee876d7..1f1a4bd6847 100644
--- a/gdb/defs.h
+++ b/gdb/defs.h
@@ -333,6 +333,9 @@ typedef void (make_cleanup_ftype) (void *);
extern struct cleanup *make_cleanup (make_cleanup_ftype *, void *);
+extern struct cleanup *make_cleanup_dtor (make_cleanup_ftype *, void *,
+ void (*dtor) (void *));
+
extern struct cleanup *make_cleanup_freeargv (char **);
struct ui_file;
diff --git a/gdb/gdbthread.h b/gdb/gdbthread.h
index 76b8f6cb539..3f1d217e3e6 100644
--- a/gdb/gdbthread.h
+++ b/gdb/gdbthread.h
@@ -45,15 +45,21 @@ struct thread_info
use is_executing instead. */
int executing_;
- /* Frontend view of the running state. Note that this is different
- from EXECUTING. When the thread is stopped internally while
- handling an internal event, like a software single-step
- breakpoint, executing will be false, but running will still be
- true. As a possible future extension, this could turn into
- enum { stopped, stepping, finishing, until(ling), ... } */
+ /* Frontend view of the thread state. Note that the RUNNING/STOPPED
+ states are different from EXECUTING. When the thread is stopped
+ internally while handling an internal event, like a software
+ single-step breakpoint, EXECUTING will be false, but running will
+ still be true. As a possible future extension, this could turn
+ into enum { stopped, exited, stepping, finishing, until(ling),
+ running ... } */
/* This field is internal to thread.c. Never access it directly,
use is_running instead. */
- int running_;
+ int state_;
+
+ /* If this is > 0, then it means there's code out there that relies
+ on this thread being listed. Don't delete it from the lists even
+ if we detect it exiting. */
+ int refcount;
/* State from wait_for_inferior */
CORE_ADDR prev_pc;
@@ -207,6 +213,13 @@ extern int is_running (ptid_t ptid);
/* Reports if any thread is known to be running right now. */
extern int any_running (void);
+/* Is this thread listed, but known to have exited? We keep it listed
+ (but not visible) until it's safe to delete. */
+extern int is_exited (ptid_t ptid);
+
+/* Is this thread stopped? */
+extern int is_stopped (ptid_t ptid);
+
/* Marks thread PTID as executing, or as stopped.
If PIDGET (PTID) is -1, marks all threads. */
extern void set_executing (ptid_t ptid, int executing);
@@ -223,8 +236,7 @@ extern int print_thread_events;
extern void print_thread_info (struct ui_out *uiout, int thread);
-extern struct cleanup *make_cleanup_restore_current_thread (ptid_t,
- struct frame_id);
+extern struct cleanup *make_cleanup_restore_current_thread (void);
#endif /* GDBTHREAD_H */
diff --git a/gdb/inf-loop.c b/gdb/inf-loop.c
index 94ced19ad98..0572d8ce016 100644
--- a/gdb/inf-loop.c
+++ b/gdb/inf-loop.c
@@ -116,20 +116,8 @@ inferior_event_handler (enum inferior_event_type event_type,
bpstat_do_actions (&stop_bpstat);
}
- /* If no breakpoint command resumed the inferior, prepare for
- interaction with the user. */
- if (!is_running (inferior_ptid))
- {
- if (was_sync)
- {
- display_gdb_prompt (0);
- }
- else
- {
- if (exec_done_display_p)
- printf_unfiltered (_("completed.\n"));
- }
- }
+ if (!was_sync && !is_running (inferior_ptid) && exec_done_display_p)
+ printf_unfiltered (_("completed.\n"));
break;
case INF_EXEC_CONTINUE:
diff --git a/gdb/infcmd.c b/gdb/infcmd.c
index c62739a65be..f5fd01853be 100644
--- a/gdb/infcmd.c
+++ b/gdb/infcmd.c
@@ -611,7 +611,7 @@ start_command (char *args, int from_tty)
static int
proceed_thread_callback (struct thread_info *thread, void *arg)
{
- if (is_running (thread->ptid))
+ if (!is_stopped (thread->ptid))
return 0;
context_switch_to (thread->ptid);
@@ -696,19 +696,13 @@ Can't resume all threads and specify proceed count simultaneously."));
if (non_stop && all_threads)
{
- struct cleanup *old_chain;
- struct frame_id saved_frame_id;
-
/* 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. */
- if (!is_running (inferior_ptid))
- saved_frame_id = get_frame_id (get_selected_frame (NULL));
- else
- saved_frame_id = null_frame_id;
+ old_chain = make_cleanup_restore_current_thread ();
- old_chain = make_cleanup_restore_current_thread (inferior_ptid, saved_frame_id);
iterate_over_threads (proceed_thread_callback, NULL);
/* Restore selected ptid. */
diff --git a/gdb/infrun.c b/gdb/infrun.c
index f74b945eb42..44e67900e32 100644
--- a/gdb/infrun.c
+++ b/gdb/infrun.c
@@ -48,6 +48,7 @@
#include "gdb_assert.h"
#include "mi/mi-common.h"
+#include "event-top.h"
/* Prototypes for local functions */
@@ -1530,11 +1531,20 @@ fetch_inferior_event (void *client_data)
{
struct execution_control_state ecss;
struct execution_control_state *ecs = &ecss;
+ struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
+ int was_sync = sync_execution;
memset (ecs, 0, sizeof (*ecs));
overlay_cache_invalid = 1;
+ if (non_stop)
+ /* In non-stop mode, the user/frontend should not notice a thread
+ switch due to internal events. Make sure we reverse to the
+ user selected thread and frame after handling the event and
+ running any breakpoint commands. */
+ make_cleanup_restore_current_thread ();
+
/* We have to invalidate the registers BEFORE calling target_wait
because they can be loaded from the target while in target_wait.
This makes remote debugging a bit more efficient for those
@@ -1571,6 +1581,14 @@ fetch_inferior_event (void *client_data)
else
inferior_event_handler (INF_EXEC_COMPLETE, NULL);
}
+
+ /* Revert thread and frame. */
+ do_cleanups (old_chain);
+
+ /* If the inferior was in sync execution mode, and now isn't,
+ restore the prompt. */
+ if (was_sync && !sync_execution)
+ display_gdb_prompt (0);
}
/* Prepare an execution control state for looping through a
@@ -3709,6 +3727,11 @@ normal_stop (void)
get_last_target_status (&last_ptid, &last);
+ /* In non-stop mode, we don't want GDB to switch threads behind the
+ user's back, to avoid races where the user is typing a command to
+ apply to thread x, but GDB switches to thread y before the user
+ finishes entering the command. */
+
/* As with the notification of thread events, we want to delay
notifying the user that we've switched thread context until
the inferior actually stops.
@@ -3716,7 +3739,8 @@ normal_stop (void)
There's no point in saying anything if the inferior has exited.
Note that SIGNALLED here means "exited with a signal", not
"received a signal". */
- if (!ptid_equal (previous_inferior_ptid, inferior_ptid)
+ if (!non_stop
+ && !ptid_equal (previous_inferior_ptid, inferior_ptid)
&& target_has_execution
&& last.kind != TARGET_WAITKIND_SIGNALLED
&& last.kind != TARGET_WAITKIND_EXITED)
diff --git a/gdb/linux-nat.c b/gdb/linux-nat.c
index ed13014ca09..967beb4a9f8 100644
--- a/gdb/linux-nat.c
+++ b/gdb/linux-nat.c
@@ -1077,48 +1077,12 @@ linux_nat_switch_fork (ptid_t new_ptid)
{
struct lwp_info *lp;
- init_thread_list ();
init_lwp_list ();
lp = add_lwp (new_ptid);
- add_thread_silent (new_ptid);
lp->stopped = 1;
-}
-
-/* Record a PTID for later deletion. */
-
-struct saved_ptids
-{
- ptid_t ptid;
- struct saved_ptids *next;
-};
-static struct saved_ptids *threads_to_delete;
-
-static void
-record_dead_thread (ptid_t ptid)
-{
- struct saved_ptids *p = xmalloc (sizeof (struct saved_ptids));
- p->ptid = ptid;
- p->next = threads_to_delete;
- threads_to_delete = p;
-}
-/* Delete any dead threads which are not the current thread. */
-
-static void
-prune_lwps (void)
-{
- struct saved_ptids **p = &threads_to_delete;
-
- while (*p)
- if (! ptid_equal ((*p)->ptid, inferior_ptid))
- {
- struct saved_ptids *tmp = *p;
- delete_thread (tmp->ptid);
- *p = tmp->next;
- xfree (tmp);
- }
- else
- p = &(*p)->next;
+ init_thread_list ();
+ add_thread_silent (new_ptid);
}
/* Handle the exit of a single thread LP. */
@@ -1133,11 +1097,7 @@ exit_lwp (struct lwp_info *lp)
if (print_thread_events)
printf_unfiltered (_("[%s exited]\n"), target_pid_to_str (lp->ptid));
- /* Core GDB cannot deal with us deleting the current thread. */
- if (!ptid_equal (lp->ptid, inferior_ptid))
- delete_thread (lp->ptid);
- else
- record_dead_thread (lp->ptid);
+ delete_thread (lp->ptid);
}
delete_lwp (lp->ptid);
@@ -1675,8 +1635,6 @@ linux_nat_resume (ptid_t ptid, int step, enum target_signal signo)
signo ? strsignal (signo) : "0",
target_pid_to_str (inferior_ptid));
- prune_lwps ();
-
if (target_can_async_p ())
/* Block events while we're here. */
linux_nat_async_events (sigchld_sync);
diff --git a/gdb/mi/mi-main.c b/gdb/mi/mi-main.c
index 06e9d63b0e4..a82d2f00b12 100644
--- a/gdb/mi/mi-main.c
+++ b/gdb/mi/mi-main.c
@@ -1059,6 +1059,24 @@ mi_cmd_execute (struct mi_parse *parse)
if (parse->cmd->argv_func != NULL)
{
+ if (target_can_async_p ()
+ && target_has_execution
+ && (is_exited (inferior_ptid))
+ && (strcmp (parse->command, "thread-info") != 0
+ && strcmp (parse->command, "thread-list-ids") != 0
+ && strcmp (parse->command, "thread-select") != 0))
+ {
+ struct ui_file *stb;
+ stb = mem_fileopen ();
+
+ fputs_unfiltered ("Cannot execute command ", stb);
+ fputstr_unfiltered (parse->command, '"', stb);
+ fputs_unfiltered (" without a selected thread", stb);
+
+ make_cleanup_ui_file_delete (stb);
+ error_stream (stb);
+ }
+
if ((!non_stop && any_running ())
|| (non_stop && is_running (inferior_ptid)))
{
diff --git a/gdb/thread.c b/gdb/thread.c
index 1ae9adfebef..c3a63fccd2d 100644
--- a/gdb/thread.c
+++ b/gdb/thread.c
@@ -41,7 +41,6 @@
#include "ui-out.h"
#include "observer.h"
#include "annotate.h"
-
#include "cli/cli-decode.h"
/* Definition of struct thread_info exported to gdbthread.h */
@@ -65,7 +64,16 @@ static void thread_apply_command (char *, int);
static void restore_current_thread (ptid_t);
static void prune_threads (void);
-static int main_thread_running = 0;
+/* Frontend view of the thread state. Possible extensions: stepping,
+ finishing, until(ling),... */
+enum thread_state
+{
+ THREAD_STOPPED,
+ THREAD_RUNNING,
+ THREAD_EXITED,
+};
+
+static enum thread_state main_thread_state = THREAD_STOPPED;
static int main_thread_executing = 0;
void
@@ -86,16 +94,25 @@ delete_step_resume_breakpoint (void *arg)
}
static void
-free_thread (struct thread_info *tp)
+clear_thread_inferior_resources (struct thread_info *tp)
{
/* NOTE: this will take care of any left-over step_resume breakpoints,
but not any user-specified thread-specific breakpoints. We can not
delete the breakpoint straight-off, because the inferior might not
be stopped at the moment. */
if (tp->step_resume_breakpoint)
- tp->step_resume_breakpoint->disposition = disp_del_at_next_stop;
+ {
+ tp->step_resume_breakpoint->disposition = disp_del_at_next_stop;
+ tp->step_resume_breakpoint = NULL;
+ }
bpstat_clear (&tp->stop_bpstat);
+}
+
+static void
+free_thread (struct thread_info *tp)
+{
+ clear_thread_inferior_resources (tp);
/* FIXME: do I ever need to call the back-end to give it a
chance at this private data before deleting the thread? */
@@ -111,7 +128,7 @@ init_thread_list (void)
struct thread_info *tp, *tpnext;
highest_thread_num = 0;
- main_thread_running = 0;
+ main_thread_state = THREAD_STOPPED;
main_thread_executing = 0;
if (!thread_list)
@@ -131,6 +148,49 @@ add_thread_silent (ptid_t ptid)
{
struct thread_info *tp;
+ tp = find_thread_pid (ptid);
+ if (tp)
+ /* Found an old thread with the same id. It has to be dead,
+ otherwise we wouldn't be adding a new thread with the same id.
+ The OS is reusing this id --- delete it, and recreate a new
+ one. */
+ {
+ /* In addition to deleting the thread, if this is the current
+ thread, then we need to also get rid of the current infrun
+ context, and take care that delete_thread doesn't really
+ delete the thread if it is inferior_ptid. Create a new
+ template thread in the list with an invalid ptid, context
+ switch to it, delete the original thread, reset the new
+ thread's ptid, and switch to it. */
+
+ if (ptid_equal (inferior_ptid, ptid))
+ {
+ tp = xmalloc (sizeof (*tp));
+ memset (tp, 0, sizeof (*tp));
+ tp->ptid = minus_one_ptid;
+ tp->num = ++highest_thread_num;
+ tp->next = thread_list;
+ thread_list = tp;
+ context_switch_to (minus_one_ptid);
+
+ /* Now we can delete it. */
+ delete_thread (ptid);
+
+ /* Since the context is already set to this new thread,
+ reset its ptid, and reswitch inferior_ptid to it. */
+ tp->ptid = ptid;
+ switch_to_thread (ptid);
+
+ observer_notify_new_thread (tp);
+
+ /* All done. */
+ return tp;
+ }
+ else
+ /* Just go ahead and delete it. */
+ delete_thread (ptid);
+ }
+
tp = (struct thread_info *) xmalloc (sizeof (*tp));
memset (tp, 0, sizeof (*tp));
tp->ptid = ptid;
@@ -179,17 +239,44 @@ delete_thread_1 (ptid_t ptid, int silent)
if (!tp)
return;
+ /* If this is the current thread, or there's code out there that
+ relies on it existing (refcount > 0) we can't delete yet. Mark
+ it as exited, and notify it. */
+ if (tp->refcount > 0
+ || ptid_equal (tp->ptid, inferior_ptid))
+ {
+ if (tp->state_ != THREAD_EXITED)
+ {
+ if (!silent)
+ observer_notify_thread_exit (tp);
+
+ /* Tag it as exited. */
+ tp->state_ = THREAD_EXITED;
+
+ /* Clear breakpoints, etc. associated with this thread. */
+ clear_thread_inferior_resources (tp);
+ }
+
+ /* Will be really deleted some other time. */
+ return;
+ }
+
if (tpprev)
tpprev->next = tp->next;
else
thread_list = tp->next;
- if (!silent)
+ /* Notify thread exit, but only if we haven't already. */
+ if (!silent && tp->state_ != THREAD_EXITED)
observer_notify_thread_exit (tp);
free_thread (tp);
}
+/* Delete thread PTID and notify of thread exit. If this is
+ inferior_ptid, don't actually delete it, but tag it as exited and
+ do the notification. If PTID is the user selected thread, clear
+ it. */
void
delete_thread (ptid_t ptid)
{
@@ -245,11 +332,14 @@ struct thread_info *
iterate_over_threads (int (*callback) (struct thread_info *, void *),
void *data)
{
- struct thread_info *tp;
+ struct thread_info *tp, *next;
- for (tp = thread_list; tp; tp = tp->next)
- if ((*callback) (tp, data))
- return tp;
+ for (tp = thread_list; tp; tp = next)
+ {
+ next = tp->next;
+ if ((*callback) (tp, data))
+ return tp;
+ }
return NULL;
}
@@ -328,6 +418,8 @@ do_captured_list_thread_ids (struct ui_out *uiout, void *arg)
for (tp = thread_list; tp; tp = tp->next)
{
+ if (tp->state_ == THREAD_EXITED)
+ continue;
num++;
ui_out_field_int (uiout, "thread-id", tp->num);
}
@@ -478,13 +570,10 @@ save_infrun_state (ptid_t ptid,
static int
thread_alive (struct thread_info *tp)
{
- if (PIDGET (tp->ptid) == -1)
+ if (tp->state_ == THREAD_EXITED)
return 0;
if (!target_thread_alive (tp->ptid))
- {
- tp->ptid = pid_to_ptid (-1); /* Mark it as dead */
- return 0;
- }
+ return 0;
return 1;
}
@@ -516,9 +605,11 @@ set_running (ptid_t ptid, int running)
the main thread is always present in the thread list. If it's
not, the first call to context_switch will mess up GDB internal
state. */
- if (running && !main_thread_running && !suppress_resume_observer)
+ if (running
+ && main_thread_state != THREAD_RUNNING
+ && !suppress_resume_observer)
observer_notify_target_resumed (ptid);
- main_thread_running = running;
+ main_thread_state = running ? THREAD_RUNNING : THREAD_STOPPED;
return;
}
@@ -530,25 +621,31 @@ set_running (ptid_t ptid, int running)
int any_started = 0;
for (tp = thread_list; tp; tp = tp->next)
{
- if (running && !tp->running_)
- any_started = 1;
- tp->running_ = running;
+ if (tp->state_ == THREAD_EXITED)
+ continue;
+ if (running && tp->state_ == THREAD_STOPPED)
+ any_started = 1;
+ tp->state_ = running ? THREAD_RUNNING : THREAD_STOPPED;
}
if (any_started && !suppress_resume_observer)
observer_notify_target_resumed (ptid);
}
else
{
+ int started = 0;
tp = find_thread_pid (ptid);
gdb_assert (tp);
- if (running && !tp->running_ && !suppress_resume_observer)
- observer_notify_target_resumed (ptid);
- tp->running_ = running;
- }
+ gdb_assert (tp->state_ != THREAD_EXITED);
+ if (running && tp->state_ == THREAD_STOPPED)
+ started = 1;
+ tp->state_ = running ? THREAD_RUNNING : THREAD_STOPPED;
+ if (started && !suppress_resume_observer)
+ observer_notify_target_resumed (ptid);
+ }
}
-int
-is_running (ptid_t ptid)
+static int
+is_thread_state (ptid_t ptid, enum thread_state state)
{
struct thread_info *tp;
@@ -556,11 +653,41 @@ is_running (ptid_t ptid)
return 0;
if (!thread_list)
- return main_thread_running;
+ return main_thread_state == state;
tp = find_thread_pid (ptid);
gdb_assert (tp);
- return tp->running_;
+ return tp->state_ == state;
+}
+
+int
+is_stopped (ptid_t ptid)
+{
+ /* Without execution, this property is always true. */
+ if (!target_has_execution)
+ return 1;
+
+ return is_thread_state (ptid, THREAD_STOPPED);
+}
+
+int
+is_exited (ptid_t ptid)
+{
+ /* Without execution, this property is always false. */
+ if (!target_has_execution)
+ return 0;
+
+ return is_thread_state (ptid, THREAD_EXITED);
+}
+
+int
+is_running (ptid_t ptid)
+{
+ /* Without execution, this property is always false. */
+ if (!target_has_execution)
+ return 0;
+
+ return is_thread_state (ptid, THREAD_RUNNING);
}
int
@@ -572,10 +699,10 @@ any_running (void)
return 0;
if (!thread_list)
- return main_thread_running;
+ return main_thread_state == THREAD_RUNNING;
for (tp = thread_list; tp; tp = tp->next)
- if (tp->running_)
+ if (tp->state_ == THREAD_RUNNING)
return 1;
return 0;
@@ -627,7 +754,7 @@ set_executing (ptid_t ptid, int executing)
/* Prints the list of threads and their details on UIOUT.
This is a version of 'info_thread_command' suitable for
use from MI.
- If REQESTED_THREAD is not -1, it's the GDB id of the thread
+ If REQUESTED_THREAD is not -1, it's the GDB id of the thread
that should be printed. Otherwise, all threads are
printed. */
void
@@ -635,24 +762,18 @@ print_thread_info (struct ui_out *uiout, int requested_thread)
{
struct thread_info *tp;
ptid_t current_ptid;
- struct frame_info *cur_frame;
struct cleanup *old_chain;
- struct frame_id saved_frame_id;
char *extra_info;
int current_thread = -1;
- /* Backup current thread and selected frame. */
- if (!is_running (inferior_ptid))
- saved_frame_id = get_frame_id (get_selected_frame (NULL));
- else
- saved_frame_id = null_frame_id;
-
- old_chain = make_cleanup_restore_current_thread (inferior_ptid, saved_frame_id);
- make_cleanup_ui_out_list_begin_end (uiout, "threads");
-
prune_threads ();
target_find_new_threads ();
current_ptid = inferior_ptid;
+
+ /* We'll be switching threads temporarily. */
+ old_chain = make_cleanup_restore_current_thread ();
+
+ make_cleanup_ui_out_list_begin_end (uiout, "threads");
for (tp = thread_list; tp; tp = tp->next)
{
struct cleanup *chain2;
@@ -660,13 +781,16 @@ print_thread_info (struct ui_out *uiout, int requested_thread)
if (requested_thread != -1 && tp->num != requested_thread)
continue;
+ if (ptid_equal (tp->ptid, current_ptid))
+ current_thread = tp->num;
+
+ if (tp->state_ == THREAD_EXITED)
+ continue;
+
chain2 = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
if (ptid_equal (tp->ptid, current_ptid))
- {
- current_thread = tp->num;
- ui_out_text (uiout, "* ");
- }
+ ui_out_text (uiout, "* ");
else
ui_out_text (uiout, " ");
@@ -674,15 +798,19 @@ print_thread_info (struct ui_out *uiout, int requested_thread)
ui_out_text (uiout, " ");
ui_out_field_string (uiout, "target-id", target_tid_to_str (tp->ptid));
- extra_info = target_extra_thread_info (tp);
- if (extra_info)
+ if (tp->state_ != THREAD_EXITED)
{
- ui_out_text (uiout, " (");
- ui_out_field_string (uiout, "details", extra_info);
- ui_out_text (uiout, ")");
+ extra_info = target_extra_thread_info (tp);
+ if (extra_info)
+ {
+ ui_out_text (uiout, " (");
+ ui_out_field_string (uiout, "details", extra_info);
+ ui_out_text (uiout, ")");
+ }
+ ui_out_text (uiout, " ");
}
- ui_out_text (uiout, " ");
- if (tp->running_)
+
+ if (tp->state_ == THREAD_RUNNING)
ui_out_text (uiout, "(running)\n");
else
{
@@ -704,24 +832,15 @@ print_thread_info (struct ui_out *uiout, int requested_thread)
if (requested_thread == -1)
{
- gdb_assert (current_thread != -1 || !thread_list);
+ gdb_assert (current_thread != -1
+ || !thread_list);
if (current_thread != -1 && ui_out_is_mi_like_p (uiout))
ui_out_field_int (uiout, "current-thread-id", current_thread);
- }
-
- if (is_running (inferior_ptid))
- return;
- /* If case we were not able to find the original frame, print the
- new selected frame. */
- if (frame_find_by_id (saved_frame_id) == NULL)
- {
- warning (_("Couldn't restore frame in current thread, at frame 0"));
- /* For MI, we should probably have a notification about
- current frame change. But this error is not very likely, so
- don't bother for now. */
- if (!ui_out_is_mi_like_p (uiout))
- print_stack_frame (get_selected_frame (NULL), 0, LOCATION);
+ if (current_thread != -1 && is_exited (current_ptid))
+ ui_out_message (uiout, 0, "\n\
+The current thread <Thread ID %d> has terminated. See `help thread'.\n",
+ current_thread);
}
}
@@ -751,7 +870,10 @@ switch_to_thread (ptid_t ptid)
reinit_frame_cache ();
registers_changed ();
- if (!is_executing (ptid))
+ /* We don't check for is_stopped, because we're called at times
+ while in the TARGET_RUNNING state, e.g., while handling an
+ internal event. */
+ if (!is_exited (ptid) && !is_executing (ptid))
stop_pc = read_pc ();
else
stop_pc = ~(CORE_ADDR) 0;
@@ -762,21 +884,63 @@ restore_current_thread (ptid_t ptid)
{
if (!ptid_equal (ptid, inferior_ptid))
{
- switch_to_thread (ptid);
+ if (non_stop)
+ context_switch_to (ptid);
+ else
+ switch_to_thread (ptid);
}
}
static void
-restore_selected_frame (struct frame_id a_frame_id)
+restore_selected_frame (struct frame_id a_frame_id, int frame_level)
{
- struct frame_info *selected_frame_info = NULL;
+ struct frame_info *frame = NULL;
+ int count;
+
+ gdb_assert (frame_level >= 0);
+
+ /* Restore by level first, check if the frame id is the same as
+ expected. If that fails, try restoring by frame id. If that
+ fails, nothing to do, just warn the user. */
+
+ count = frame_level;
+ frame = find_relative_frame (get_current_frame (), &count);
+ if (count == 0
+ && frame != NULL
+ /* Either the frame ids match, of they're both invalid. The
+ latter case is not failsafe, but since it's highly unlikely
+ the search by level finds the wrong frame, it's 99.9(9)% of
+ the time (for all practical purposes) safe. */
+ && (frame_id_eq (get_frame_id (frame), a_frame_id)
+ /* Note: could be better to check every frame_id
+ member for equality here. */
+ || (!frame_id_p (get_frame_id (frame))
+ && !frame_id_p (a_frame_id))))
+ {
+ /* Cool, all is fine. */
+ select_frame (frame);
+ return;
+ }
- if (frame_id_eq (a_frame_id, null_frame_id))
- return;
+ frame = frame_find_by_id (a_frame_id);
+ if (frame != NULL)
+ {
+ /* Cool, refound it. */
+ select_frame (frame);
+ return;
+ }
- if ((selected_frame_info = frame_find_by_id (a_frame_id)) != NULL)
+ /* Nothing else to do, the frame layout really changed.
+ Tell the user. */
+ if (!ui_out_is_mi_like_p (uiout))
{
- select_frame (selected_frame_info);
+ warning (_("\
+Couldn't restore frame #%d in current thread, at reparsed frame #0\n"),
+ frame_level);
+ /* For MI, we should probably have a notification about
+ current frame change. But this error is not very
+ likely, so don't bother for now. */
+ print_stack_frame (frame, 1, SRC_LINE);
}
}
@@ -784,31 +948,66 @@ struct current_thread_cleanup
{
ptid_t inferior_ptid;
struct frame_id selected_frame_id;
+ int selected_frame_level;
+ int was_stopped;
};
static void
do_restore_current_thread_cleanup (void *arg)
{
+ struct thread_info *tp;
struct current_thread_cleanup *old = arg;
restore_current_thread (old->inferior_ptid);
- /* A command like 'thread apply all $exec_command&' may change the
- running state of the originally selected thread, so we have to
- recheck it here. */
- if (!is_running (old->inferior_ptid))
- restore_selected_frame (old->selected_frame_id);
+ /* The running state of the originally selected thread may have
+ changed, so we have to recheck it here. */
+ if (old->was_stopped
+ && is_stopped (inferior_ptid)
+ && target_has_registers
+ && target_has_stack
+ && target_has_memory)
+ restore_selected_frame (old->selected_frame_id,
+ old->selected_frame_level);
+}
+
+static void
+restore_current_thread_cleanup_dtor (void *arg)
+{
+ struct current_thread_cleanup *old = arg;
+ struct thread_info *tp;
+ tp = find_thread_pid (old->inferior_ptid);
+ if (tp)
+ tp->refcount--;
xfree (old);
}
struct cleanup *
-make_cleanup_restore_current_thread (ptid_t inferior_ptid,
- struct frame_id a_frame_id)
+make_cleanup_restore_current_thread (void)
{
- struct current_thread_cleanup *old
- = xmalloc (sizeof (struct current_thread_cleanup));
+ struct thread_info *tp;
+ struct frame_info *frame;
+ struct current_thread_cleanup *old;
+
+ old = xmalloc (sizeof (struct current_thread_cleanup));
old->inferior_ptid = inferior_ptid;
- old->selected_frame_id = a_frame_id;
- return make_cleanup (do_restore_current_thread_cleanup, old);
+ old->was_stopped = is_stopped (inferior_ptid);
+ if (old->was_stopped
+ && target_has_registers
+ && target_has_stack
+ && target_has_memory)
+ frame = get_selected_frame (NULL);
+ else
+ frame = NULL;
+
+ old->selected_frame_id = get_frame_id (frame);
+ old->selected_frame_level = frame_relative_level (frame);
+
+ tp = find_thread_pid (inferior_ptid);
+ if (tp)
+ tp->refcount++;
+
+ return make_cleanup_dtor (do_restore_current_thread_cleanup, old,
+ restore_current_thread_cleanup_dtor);
}
/* Apply a GDB command to a list of threads. List syntax is a whitespace
@@ -824,27 +1023,17 @@ static void
thread_apply_all_command (char *cmd, int from_tty)
{
struct thread_info *tp;
- struct cleanup *old_chain = make_cleanup (null_cleanup, 0);
+ struct cleanup *old_chain;
char *saved_cmd;
- struct frame_id saved_frame_id;
- ptid_t current_ptid;
- int thread_has_changed = 0;
if (cmd == NULL || *cmd == '\000')
error (_("Please specify a command following the thread ID list"));
-
- current_ptid = inferior_ptid;
- if (!is_running (inferior_ptid))
- saved_frame_id = get_frame_id (get_selected_frame (NULL));
- else
- saved_frame_id = null_frame_id;
- make_cleanup_restore_current_thread (inferior_ptid, saved_frame_id);
-
- /* It is safe to update the thread list now, before
- traversing it for "thread apply all". MVS */
+ prune_threads ();
target_find_new_threads ();
+ old_chain = make_cleanup_restore_current_thread ();
+
/* Save a copy of the command in case it is clobbered by
execute_command */
saved_cmd = xstrdup (cmd);
@@ -863,13 +1052,7 @@ thread_apply_all_command (char *cmd, int from_tty)
strcpy (cmd, saved_cmd); /* Restore exact command used previously */
}
- if (!ptid_equal (current_ptid, inferior_ptid))
- thread_has_changed = 1;
-
do_cleanups (old_chain);
- /* Print stack frame only if we changed thread. */
- if (thread_has_changed && !is_running (inferior_ptid))
- print_stack_frame (get_current_frame (), 1, SRC_LINE);
}
static void
@@ -878,11 +1061,7 @@ thread_apply_command (char *tidlist, int from_tty)
char *cmd;
char *p;
struct cleanup *old_chain;
- struct cleanup *saved_cmd_cleanup_chain;
char *saved_cmd;
- struct frame_id saved_frame_id;
- ptid_t current_ptid;
- int thread_has_changed = 0;
if (tidlist == NULL || *tidlist == '\000')
error (_("Please specify a thread ID list"));
@@ -892,18 +1071,10 @@ thread_apply_command (char *tidlist, int from_tty)
if (*cmd == '\000')
error (_("Please specify a command following the thread ID list"));
- current_ptid = inferior_ptid;
-
- if (!is_running (inferior_ptid))
- saved_frame_id = get_frame_id (get_selected_frame (NULL));
- else
- saved_frame_id = null_frame_id;
- old_chain = make_cleanup_restore_current_thread (inferior_ptid, saved_frame_id);
-
/* Save a copy of the command in case it is clobbered by
execute_command */
saved_cmd = xstrdup (cmd);
- saved_cmd_cleanup_chain = make_cleanup (xfree, (void *) saved_cmd);
+ old_chain = make_cleanup (xfree, saved_cmd);
while (tidlist < cmd)
{
struct thread_info *tp;
@@ -941,26 +1112,24 @@ thread_apply_command (char *tidlist, int from_tty)
warning (_("Thread %d has terminated."), start);
else
{
+ make_cleanup_restore_current_thread ();
+
if (non_stop)
context_switch_to (tp->ptid);
else
switch_to_thread (tp->ptid);
+
printf_filtered (_("\nThread %d (%s):\n"), tp->num,
target_tid_to_str (inferior_ptid));
execute_command (cmd, from_tty);
- strcpy (cmd, saved_cmd); /* Restore exact command used previously */
+
+ /* Restore exact command used previously. */
+ strcpy (cmd, saved_cmd);
}
}
}
- if (!ptid_equal (current_ptid, inferior_ptid))
- thread_has_changed = 1;
-
- do_cleanups (saved_cmd_cleanup_chain);
do_cleanups (old_chain);
- /* Print stack frame only if we changed thread. */
- if (thread_has_changed)
- print_stack_frame (get_current_frame (), 1, SRC_LINE);
}
/* Switch to the specified thread. Will dispatch off to thread_apply_command
@@ -971,11 +1140,17 @@ thread_command (char *tidstr, int from_tty)
{
if (!tidstr)
{
- /* Don't generate an error, just say which thread is current. */
if (target_has_stack)
- printf_filtered (_("[Current thread is %d (%s)]\n"),
- pid_to_thread_id (inferior_ptid),
- target_tid_to_str (inferior_ptid));
+ {
+ if (is_exited (inferior_ptid))
+ printf_filtered (_("[Current thread is %d (%s) (exited)]\n"),
+ pid_to_thread_id (inferior_ptid),
+ target_tid_to_str (inferior_ptid));
+ else
+ printf_filtered (_("[Current thread is %d (%s)]\n"),
+ pid_to_thread_id (inferior_ptid),
+ target_tid_to_str (inferior_ptid));
+ }
else
error (_("No stack."));
return;
@@ -1023,10 +1198,16 @@ do_captured_thread_select (struct ui_out *uiout, void *tidstr)
ui_out_text (uiout, target_tid_to_str (inferior_ptid));
ui_out_text (uiout, ")]");
- if (!tp->running_)
- print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
- else
+ /* Note that we can't reach this with an exited thread, due to the
+ thread_alive check above. */
+ if (tp->state_ == THREAD_RUNNING)
ui_out_text (uiout, "(running)\n");
+ else
+ print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
+
+ /* Since the current thread may have changed, see if there is any
+ exited thread we can now delete. */
+ prune_threads ();
return GDB_RC_OK;
}
@@ -1052,19 +1233,25 @@ _initialize_thread (void)
c = add_info ("threads", info_threads_command,
_("IDs of currently known threads."));
set_cmd_async_ok (c);
+ set_cmd_no_selected_thread_ok (c);
c = add_prefix_cmd ("thread", class_run, thread_command, _("\
Use this command to switch between threads.\n\
The new thread ID must be currently known."),
&thread_cmd_list, "thread ", 1, &cmdlist);
set_cmd_async_ok (c);
+ set_cmd_no_selected_thread_ok (c);
- add_prefix_cmd ("apply", class_run, thread_apply_command,
- _("Apply a command to a list of threads."),
- &thread_apply_list, "thread apply ", 1, &thread_cmd_list);
+ c = add_prefix_cmd ("apply", class_run, thread_apply_command,
+ _("Apply a command to a list of threads."),
+ &thread_apply_list, "thread apply ", 1, &thread_cmd_list);
+ set_cmd_async_ok (c);
+ set_cmd_no_selected_thread_ok (c);
- add_cmd ("all", class_run, thread_apply_all_command,
- _("Apply a command to all threads."), &thread_apply_list);
+ c = add_cmd ("all", class_run, thread_apply_all_command,
+ _("Apply a command to all threads."), &thread_apply_list);
+ set_cmd_async_ok (c);
+ set_cmd_no_selected_thread_ok (c);
if (!xdb_commands)
add_com_alias ("t", "thread", class_run, 1);
diff --git a/gdb/top.c b/gdb/top.c
index fe4b1d0aebd..86738e7c160 100644
--- a/gdb/top.c
+++ b/gdb/top.c
@@ -362,6 +362,8 @@ do_chdir_cleanup (void *old_dir)
/* Execute the line P as a command.
Pass FROM_TTY as second argument to the defining function. */
+/* Execute command P, in the current user context. */
+
void
execute_command (char *p, int from_tty)
{
@@ -415,12 +417,19 @@ execute_command (char *p, int from_tty)
c = lookup_cmd (&p, cmdlist, "", 0, 1);
- /* If the target is running, we allow only a limited set of
- commands. */
+ /* If the selected thread has terminated, we allow only a
+ limited set of commands. */
if (target_can_async_p ()
- && ((!non_stop && any_running ())
- || (non_stop && is_running (inferior_ptid)))
- && !get_cmd_async_ok (c))
+ && is_exited (inferior_ptid)
+ && !get_cmd_no_selected_thread_ok (c))
+ error (_("\
+Cannot execute this command without a live selected thread. See `help thread'."));
+ /* If the target is running, we allow only a limited set of
+ commands. */
+ else if (target_can_async_p ()
+ && ((!non_stop && any_running ())
+ || (non_stop && is_running (inferior_ptid)))
+ && !get_cmd_async_ok (c))
error (_("Cannot execute this command while the target is running."));
/* Pass null arg rather than an empty one. */
diff --git a/gdb/utils.c b/gdb/utils.c
index cdea5a66394..e1901d1ec1a 100644
--- a/gdb/utils.c
+++ b/gdb/utils.c
@@ -208,6 +208,14 @@ make_cleanup (make_cleanup_ftype *function, void *arg)
}
struct cleanup *
+make_cleanup_dtor (make_cleanup_ftype *function, void *arg,
+ void (*dtor) (void *))
+{
+ return make_my_cleanup2 (&cleanup_chain,
+ function, arg, dtor);
+}
+
+struct cleanup *
make_final_cleanup (make_cleanup_ftype *function, void *arg)
{
return make_my_cleanup (&final_cleanup_chain, function, arg);
diff --git a/gdb/varobj.c b/gdb/varobj.c
index e94a35ef4fa..3a0bf5e373d 100644
--- a/gdb/varobj.c
+++ b/gdb/varobj.c
@@ -2198,8 +2198,7 @@ c_value_of_root (struct varobj **var_handle)
/* Not a root var */
return NULL;
- back_to = make_cleanup_restore_current_thread (
- inferior_ptid, get_frame_id (deprecated_safe_get_selected_frame ()));
+ back_to = make_cleanup_restore_current_thread ();
/* Determine whether the variable is still around. */
if (var->root->valid_block == NULL || var->root->floating)