From 4034d0ff52b0f346efedd2d335ccbc672466da45 Mon Sep 17 00:00:00 2001 From: Antoine Tremblay Date: Mon, 3 Oct 2016 16:52:44 -0400 Subject: Emit inferior, thread and frame selection events to all UIs With this patch, when an inferior, thread or frame is explicitly selected by the user, notifications will appear on all CLI and MI UIs. When a GDB console is integrated in a front-end, this allows the front-end to follow a selection made by the user ont he CLI, and it informs the user about selection changes made behind the scenes by the front-end. This patch addresses PR gdb/20487. In order to communicate frame changes to the front-end, this patch adds a new field to the =thread-selected event for the selected frame. The idea is that since inferior/thread/frame can be seen as a composition, it makes sense to send them together in the same event. The vision would be to eventually send the inferior information as well, if we find that it's needed, although the "=thread-selected" event would be ill-named for that job. Front-ends need to handle this new field if they want to follow the frame selection changes that originate from the console. The format of the frame attribute is the same as what is found in the *stopped events. Here's a detailed example for each command and the events they generate: thread ------ 1. CLI command: thread 1.3 MI event: =thread-selected,id="3",frame={...} 2. MI command: -thread-select 3 CLI event: [Switching to thread 1.3 ...] 3. MI command (CLI-in-MI): thread 1.3 MI event/reply: &"thread 1.3\n" ~"#0 child_sub_function () ... =thread-selected,id="3",frame={level="0",...} ^done frame ----- 1. CLI command: frame 1 MI event: =thread-selected,id="3",frame={level="1",...} 2. MI command: -stack-select-frame 1 CLI event: #1 0x00000000004007f0 in child_function... 3. MI command (CLI-in-MI): frame 1 MI event/reply: &"frame 1\n" ~"#1 0x00000000004007f9 in ..." =thread-selected,id="3",frame={level="1"...} ^done inferior -------- Inferior selection events only go from the console to MI, since there's no way to select the inferior in pure MI. 1. CLI command: inferior 2 MI event: =thread-selected,id="3" Note that if the user selects an inferior that is not started or exited, the MI doesn't receive a notification. Since there is no threads to select, the =thread-selected event does not apply... 2. MI command (CLI-in-MI): inferior 2 MI event/reply: &"inferior 2\n" ~"[Switching to inferior 2 ...]" =thread-selected,id="4",frame={level="0"...} ^done Internal implementation detail: this patch makes it possible to suppress notifications caused by a CLI command, like what is done in mi-interp.c. This means that it's now possible to use the add_com_suppress_notification function to register a command with some event suppressed. It is used to implement the select-frame command in this patch. The function command_notifies_uscc_observer was added to extract the rather complicated logical expression from the if statement. It is also now clearer what that logic does: if the command used by the user already notifies the user_selected_context_changed observer, there is not need to notify it again. It therefore protects again emitting the event twice. No regressions, tested on ubuntu 14.04 x86 with target boards unix and native-extended-gdbserver. gdb/ChangeLog: YYYY-MM-DD Antoine Tremblay YYYY-MM-DD Simon Marchi PR gdb/20487 * NEWS: Mention new frame field of =thread-selected event. * cli/cli-decode.c (add_cmd): Initialize c->suppress_notification. (add_com_suppress_notification): New function definition. (cmd_func): Set and restore the suppress_notification flag. * cli/cli-deicode.h (struct cmd_list_element) : New field. * cli/cli-interp.c (cli_suppress_notification): New global variable. (cli_on_user_selected_context_changed): New function. (_initialize_cli_interp): Attach to user_selected_context_changed observer. * command.h (struct cli_suppress_notification): New structure. (cli_suppress_notification): New global variable declaration. (add_com_suppress_notification): New function declaration. * defs.h (enum user_selected_what_flag): New enum. (user_selected_what): New enum flag type. * frame.h (print_stack_frame_to_uiout): New function declaration. * gdbthread.h (print_selected_thread_frame): New function declaration. * inferior.c (print_selected_inferior): New function definition. (inferior_command): Remove printing of inferior/thread/frame switch notifications, notify user_selected_context_changed observer. * inferior.h (print_selected_inferior): New function declaration. * mi/mi-cmds.c (struct mi_cmd): Add user_selected_context suppression to stack-select-frame and thread-select commands. * mi/mi-interp.c (struct mi_suppress_notification) : Initialize. (mi_user_selected_context_changed): New function definition. (_initialize_mi_interp): Attach to user_selected_context_changed. * mi/mi-main.c (mi_cmd_thread_select): Print thread selection reply. (mi_execute_command): Handle notification suppression. Notify user_selected_context_changed observer on thread change instead of printing event directly. Don't send it if command already sends the notification. (command_notifies_uscc_observer): New function. (mi_cmd_execute): Don't handle notification suppression. * mi/mi-main.h (struct mi_suppress_notification) : New field. * stack.c (print_stack_frame_to_uiout): New function definition. (select_frame_command): Notify user_selected_context_changed observer. (frame_command): Call print_selected_thread_frame if there's no frame change or notify user_selected_context_changed observer if there is. (up_command): Notify user_selected_context_changed observer. (down_command): Likewise. (_initialize_stack): Suppress user_selected_context notification for command select-frame. * thread.c (thread_command): Notify user_selected_context_changed if the thread has changed, print thread info directly if it hasn't. (do_captured_thread_select): Do not print thread switch event. (print_selected_thread_frame): New function definition. * tui/tui-interp.c (tui_on_user_selected_context_changed): New function definition. (_initialize_tui_interp): Attach to user_selected_context_changed observer. gdb/doc/ChangeLog: PR gdb/20487 * gdb.texinfo (Context management): Update mention of frame change notifications. (gdb/mi Async Records): Document frame field in =thread-select event. * observer.texi (GDB Observers): New user_selected_context_changed observer. gdb/testsuite/ChangeLog: PR gdb/20487 * gdb.mi/mi-pthreads.exp (check_mi_thread_command_set): Adapt =thread-select-event check. --- gdb/thread.c | 86 ++++++++++++++++++++++++++++++++++++++++++++---------------- 1 file changed, 64 insertions(+), 22 deletions(-) (limited to 'gdb/thread.c') diff --git a/gdb/thread.c b/gdb/thread.c index a66a2b5..13449a8 100644 --- a/gdb/thread.c +++ b/gdb/thread.c @@ -1923,7 +1923,7 @@ thread_apply_command (char *tidlist, int from_tty) void thread_command (char *tidstr, int from_tty) { - if (!tidstr) + if (tidstr == NULL) { if (ptid_equal (inferior_ptid, null_ptid)) error (_("No thread selected")); @@ -1943,10 +1943,31 @@ thread_command (char *tidstr, int from_tty) } else error (_("No stack.")); - return; } + else + { + ptid_t previous_ptid = inferior_ptid; + enum gdb_rc result; + + result = gdb_thread_select (current_uiout, tidstr, NULL); + + /* If thread switch did not succeed don't notify or print. */ + if (result == GDB_RC_FAIL) + return; - gdb_thread_select (current_uiout, tidstr, NULL); + /* Print if the thread has not changed, otherwise an event will be sent. */ + if (ptid_equal (inferior_ptid, previous_ptid)) + { + print_selected_thread_frame (current_uiout, + USER_SELECTED_THREAD + | USER_SELECTED_FRAME); + } + else + { + observer_notify_user_selected_context_changed (USER_SELECTED_THREAD + | USER_SELECTED_FRAME); + } + } } /* Implementation of `thread name'. */ @@ -2058,32 +2079,53 @@ do_captured_thread_select (struct ui_out *uiout, void *tidstr_v) annotate_thread_changed (); - if (ui_out_is_mi_like_p (uiout)) - ui_out_field_int (uiout, "new-thread-id", inferior_thread ()->global_num); - else + /* Since the current thread may have changed, see if there is any + exited thread we can now delete. */ + prune_threads (); + + return GDB_RC_OK; +} + +/* Print thread and frame switch command response. */ + +void +print_selected_thread_frame (struct ui_out *uiout, + user_selected_what selection) +{ + struct thread_info *tp = inferior_thread (); + struct inferior *inf = current_inferior (); + + if (selection & USER_SELECTED_THREAD) { - ui_out_text (uiout, "[Switching to thread "); - ui_out_field_string (uiout, "new-thread-id", print_thread_id (tp)); - ui_out_text (uiout, " ("); - ui_out_text (uiout, target_pid_to_str (inferior_ptid)); - ui_out_text (uiout, ")]"); + if (ui_out_is_mi_like_p (uiout)) + { + ui_out_field_int (uiout, "new-thread-id", + inferior_thread ()->global_num); + } + else + { + ui_out_text (uiout, "[Switching to thread "); + ui_out_field_string (uiout, "new-thread-id", print_thread_id (tp)); + ui_out_text (uiout, " ("); + ui_out_text (uiout, target_pid_to_str (inferior_ptid)); + ui_out_text (uiout, ")]"); + } } - /* 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 { - ui_out_text (uiout, "\n"); - print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC, 1); + if (selection & USER_SELECTED_THREAD) + ui_out_text (uiout, "(running)\n"); } + else if (selection & USER_SELECTED_FRAME) + { + if (selection & USER_SELECTED_THREAD) + ui_out_text (uiout, "\n"); - /* Since the current thread may have changed, see if there is any - exited thread we can now delete. */ - prune_threads (); - - return GDB_RC_OK; + if (has_stack_frames ()) + print_stack_frame_to_uiout (uiout, get_selected_frame (NULL), + 1, SRC_AND_LOC, 1); + } } enum gdb_rc -- cgit v1.1