Re: [PATCH v3 07/34] Make the intepreters output to all UIs

Simon Marchi
2016-05-19T15:16:02Z

On 16-05-06 08:34 AM, Pedro Alves wrote:
> When we have multiple consoles, MI channels, etc., then we need to
> broadcast breakpoint hits, etc. to all UIs. In the past, I've
> adjusted most of the run control to communicate events to the
> interpreters through observer notifications, so events would be
> properly sent to console and MI streams, in sync and async modes.
>
> This patch does the next logical step -- have each interpreter's
> observers output interpreter-specific info to _all_ UIs.
>
> Note that when we have multiple instances of active cli/tui
> interpreters, then the cli_interp and tui_interp globals no longer
> work. This is addressed by this patch.
>
> Also, the interpreters currently register some observers when resumed
> and remove them when suspended. If we have multiple instances of the
> interpreters, and they can be suspended/resumed at different,
> independent times, that no longer works. What we instead do is always
> install the observers, and then have the observers themselves know
> when to do nothing.
>
> An earlier prototype of this series did the looping over struct UIs in
> common code, and then dispatched events to the interpreters through a
> matching interp_on_foo method for each observer. That turned out a
> lot more complicated than the present solution, as we'd end up with
> having to create a new interp method every time some interpreter
> wanted to listen to some observer notification, resulting in a lot of
> duplicated make-work and more coupling than desirable.
>
> gdb/ChangeLog:
> yyyy-mm-dd Pedro Alves <palves@redhat.com>
>
> * cli/cli-interp.c (cli_interp): Delete.
> (as_cli_interp): New function.
> (cli_on_normal_stop, cli_on_signal_received)
> (cli_on_end_stepping_range, cli_on_signal_exited, cli_on_exited)
> (cli_on_no_history): Send output to all CLI UIs.
> (cli_on_sync_execution_done, cli_on_command_error): Skip output if
> the top level interpreter is not a CLI.
> (cli_interpreter_init): Don't set cli_interp or install observers
> here.
> (_initialize_cli_interp): Install observers here.
> * event-top.c (main_ui_, ui_list): New globals.
> (current_ui): Point to main_ui_.
> (restore_ui_cleanup, switch_thru_all_uis_init)
> (switch_thru_all_uis_cond, switch_thru_all_uis_next): New
> functions.
> * mi/mi-interp.c (as_mi_interp): New function.
> (mi_interpreter_init): Don't install observers here.
> (mi_on_sync_execution_done): Skip output if the top level
> interpreter is not a MI.
> (mi_new_thread, mi_thread_exit, mi_record_changed)
> (mi_inferior_added, mi_inferior_appeared, mi_inferior_exit)
> (mi_inferior_removed): Send output to all MI UIs.
> (find_mi_interpreter, mi_interp_data): Delete.
> (find_mi_interp): New function.
> (mi_on_signal_received, mi_on_end_stepping_range)
> (mi_on_signal_exited, mi_on_exited, mi_on_no_history): Send output
> to all MI UIs.
> (mi_on_normal_stop): Rename to ...
> (mi_on_normal_stop_1): ... this.
> (mi_on_normal_stop): Reimplement, sending output to all MI UIs.
> (mi_traceframe_changed, mi_tsv_created, mi_tsv_deleted)
> (mi_tsv_modified, mi_breakpoint_created, mi_breakpoint_deleted)
> (mi_breakpoint_modified, mi_output_running_pid): Send output to
> all MI UIs.
> (mi_on_resume): Rename to ...
> (mi_on_resume_1): ... this. Don't handle infcalls here.
> (mi_on_resume): Reimplement, sending output to all MI UIs.
> (mi_solib_loaded, mi_solib_unloaded, mi_command_param_changed)
> (mi_memory_changed): Send output to all MI UIs.
> (report_initial_inferior): Install observers here.
> * top.h (struct ui) <next>: New field.
> (ui_list): Declare.
> (struct switch_thru_all_uis): New.
> (switch_thru_all_uis_init, switch_thru_all_uis_cond)
> (switch_thru_all_uis_next): Declare.
> (SWITCH_THRU_ALL_UIS): New macro.
> * tui/tui-interp.c (tui_interp): Delete global.
> (as_tui_interp): New function.
> (tui_on_normal_stop, tui_on_signal_received)
> (tui_on_end_stepping_range, tui_on_signal_exited, tui_on_exited)
> (tui_on_no_history): Send output to all TUI UIs.
> (tui_on_sync_execution_done, tui_on_command_error): Skip output if
> the top level interpreter is not a TUI.
> (tui_init): Don't set tui_interp or install observers here.
> (_initialize_tui_interp): Install observers here.
> ---
> gdb/cli/cli-interp.c | 127 +++++--
> gdb/event-top.c | 51 ++-
> gdb/mi/mi-interp.c | 919 ++++++++++++++++++++++++++++++++-------------------
> gdb/top.h | 29 ++
> gdb/tui/tui-interp.c | 127 +++++--
> 5 files changed, 841 insertions(+), 412 deletions(-)
>
> diff --git a/gdb/cli/cli-interp.c b/gdb/cli/cli-interp.c
> index ac12a4c..cd33dd2 100644
> --- a/gdb/cli/cli-interp.c
> +++ b/gdb/cli/cli-interp.c
> @@ -33,8 +33,16 @@ struct cli_interp
> struct ui_out *cli_uiout;
> };
>
> -/* The interpreter for the console interpreter. */
> -static struct interp *cli_interp;
> +/* Returns the INTERP's data cast as cli_interp if INTERP is a CLI,
> + and returns NULL otherwise. */
> +
> +static struct cli_interp *
> +as_cli_interp (struct interp *interp)
> +{
> + if (strcmp (interp_name (interp), INTERP_CONSOLE) == 0)
> + return (struct cli_interp *) interp_data (interp);
> + return NULL;
> +}
>
> /* Longjmp-safe wrapper for "execute_command". */
> static struct gdb_exception safe_execute_command (struct ui_out *uiout,
> @@ -50,10 +58,17 @@ static struct gdb_exception safe_execute_command (struct ui_out *uiout,
> static void
> cli_on_normal_stop (struct bpstats *bs, int print_frame)
> {
> - if (!interp_quiet_p (cli_interp))
> + struct switch_thru_all_uis state;
> +
> + SWITCH_THRU_ALL_UIS (state)
> {
> + struct cli_interp *cli = as_cli_interp (top_level_interpreter ());
> +
> + if (cli == NULL)
> + continue;
> +
> if (print_frame)
> - print_stop_event (interp_ui_out (cli_interp));
> + print_stop_event (cli->cli_uiout);
> }
> }
>
> @@ -62,8 +77,17 @@ cli_on_normal_stop (struct bpstats *bs, int print_frame)
> static void
> cli_on_signal_received (enum gdb_signal siggnal)
> {
> - if (!interp_quiet_p (cli_interp))
> - print_signal_received_reason (interp_ui_out (cli_interp), siggnal);
> + struct switch_thru_all_uis state;
> +
> + SWITCH_THRU_ALL_UIS (state)
> + {
> + struct cli_interp *cli = as_cli_interp (top_level_interpreter ());
> +
> + if (cli == NULL)
> + continue;
> +
> + print_signal_received_reason (cli->cli_uiout, siggnal);
> + }
> }
>
> /* Observer for the end_stepping_range notification. */
> @@ -71,8 +95,17 @@ cli_on_signal_received (enum gdb_signal siggnal)
> static void
> cli_on_end_stepping_range (void)
> {
> - if (!interp_quiet_p (cli_interp))
> - print_end_stepping_range_reason (interp_ui_out (cli_interp));
> + struct switch_thru_all_uis state;
> +
> + SWITCH_THRU_ALL_UIS (state)
> + {
> + struct cli_interp *cli = as_cli_interp (top_level_interpreter ());
> +
> + if (cli == NULL)
> + continue;
> +
> + print_end_stepping_range_reason (cli->cli_uiout);
> + }
> }
>
> /* Observer for the signalled notification. */
> @@ -80,8 +113,17 @@ cli_on_end_stepping_range (void)
> static void
> cli_on_signal_exited (enum gdb_signal siggnal)
> {
> - if (!interp_quiet_p (cli_interp))
> - print_signal_exited_reason (interp_ui_out (cli_interp), siggnal);
> + struct switch_thru_all_uis state;
> +
> + SWITCH_THRU_ALL_UIS (state)
> + {
> + struct cli_interp *cli = as_cli_interp (top_level_interpreter ());
> +
> + if (cli == NULL)
> + continue;
> +
> + print_signal_exited_reason (cli->cli_uiout, siggnal);
> + }
> }
>
> /* Observer for the exited notification. */
> @@ -89,8 +131,17 @@ cli_on_signal_exited (enum gdb_signal siggnal)
> static void
> cli_on_exited (int exitstatus)
> {
> - if (!interp_quiet_p (cli_interp))
> - print_exited_reason (interp_ui_out (cli_interp), exitstatus);
> + struct switch_thru_all_uis state;
> +
> + SWITCH_THRU_ALL_UIS (state)
> + {
> + struct cli_interp *cli = as_cli_interp (top_level_interpreter ());
> +
> + if (cli == NULL)
> + continue;
> +
> + print_exited_reason (cli->cli_uiout, exitstatus);
> + }
> }
>
> /* Observer for the no_history notification. */
> @@ -98,8 +149,17 @@ cli_on_exited (int exitstatus)
> static void
> cli_on_no_history (void)
> {
> - if (!interp_quiet_p (cli_interp))
> - print_no_history_reason (interp_ui_out (cli_interp));
> + struct switch_thru_all_uis state;
> +
> + SWITCH_THRU_ALL_UIS (state)
> + {
> + struct cli_interp *cli = as_cli_interp (top_level_interpreter ());
> +
> + if (cli == NULL)
> + continue;
> +
> + print_no_history_reason (cli->cli_uiout);
> + }
> }
>
> /* Observer for the sync_execution_done notification. */
> @@ -107,8 +167,12 @@ cli_on_no_history (void)
> static void
> cli_on_sync_execution_done (void)
> {
> - if (!interp_quiet_p (cli_interp))
> - display_gdb_prompt (NULL);
> + struct cli_interp *cli = as_cli_interp (top_level_interpreter ());
> +
> + if (cli == NULL)
> + return;
> +
> + display_gdb_prompt (NULL);
> }
>
> /* Observer for the command_error notification. */
> @@ -116,8 +180,12 @@ cli_on_sync_execution_done (void)
> static void
> cli_on_command_error (void)
> {
> - if (!interp_quiet_p (cli_interp))
> - display_gdb_prompt (NULL);
> + struct cli_interp *cli = as_cli_interp (top_level_interpreter ());
> +
> + if (cli == NULL)
> + return;
> +
> + display_gdb_prompt (NULL);
> }
>
> /* These implement the cli out interpreter: */
> @@ -125,19 +193,6 @@ cli_on_command_error (void)
> static void *
> cli_interpreter_init (struct interp *self, int top_level)
> {
> - if (top_level)
> - cli_interp = self;
> -
> - /* If changing this, remember to update tui-interp.c as well. */
> - observer_attach_normal_stop (cli_on_normal_stop);
> - observer_attach_end_stepping_range (cli_on_end_stepping_range);
> - observer_attach_signal_received (cli_on_signal_received);
> - observer_attach_signal_exited (cli_on_signal_exited);
> - observer_attach_exited (cli_on_exited);
> - observer_attach_no_history (cli_on_no_history);
> - observer_attach_sync_execution_done (cli_on_sync_execution_done);
> - observer_attach_command_error (cli_on_command_error);
> -
> return interp_data (self);
> }
>
> @@ -269,4 +324,14 @@ void
> _initialize_cli_interp (void)
> {
> interp_factory_register (INTERP_CONSOLE, cli_interp_factory);
> +
> + /* If changing this, remember to update tui-interp.c as well. */
> + observer_attach_normal_stop (cli_on_normal_stop);
> + observer_attach_end_stepping_range (cli_on_end_stepping_range);
> + observer_attach_signal_received (cli_on_signal_received);
> + observer_attach_signal_exited (cli_on_signal_exited);
> + observer_attach_exited (cli_on_exited);
> + observer_attach_no_history (cli_on_no_history);
> + observer_attach_sync_execution_done (cli_on_sync_execution_done);
> + observer_attach_command_error (cli_on_command_error);
> }
> diff --git a/gdb/event-top.c b/gdb/event-top.c
> index 664543c..c6e3b7e 100644
> --- a/gdb/event-top.c
> +++ b/gdb/event-top.c
> @@ -437,8 +437,55 @@ top_level_prompt (void)
> return xstrdup (prompt);
> }
>
> -static struct ui current_ui_;
> -struct ui *current_ui = &current_ui_;
> +/* The main UI. This is the UI that is bound to stdin/stdout/stderr.
> + It always exists and is created automatically when GDB starts
> + up. */
> +static struct ui main_ui_;
> +
> +struct ui *current_ui = &main_ui_;
> +struct ui *ui_list = &main_ui_;
> +
> +/* Cleanup that restores the current UI. */
> +
> +static void
> +restore_ui_cleanup (void *data)
> +{
> + current_ui = (struct ui *) data;
> +}
> +
> +/* See top.h. */
> +
> +void
> +switch_thru_all_uis_init (struct switch_thru_all_uis *state)
> +{
> + state->iter = ui_list;
> + state->old_chain = make_cleanup (restore_ui_cleanup, current_ui);
> +}
> +
> +/* See top.h. */
> +
> +int
> +switch_thru_all_uis_cond (struct switch_thru_all_uis *state)
> +{
> + if (state->iter != NULL)
> + {
> + current_ui = state->iter;
> + return 1;
> + }
> + else
> + {
> + do_cleanups (state->old_chain);
> + return 0;
> + }
> +}
> +
> +/* See top.h. */
> +
> +void
> +switch_thru_all_uis_next (struct switch_thru_all_uis *state)
> +{
> + state->iter = state->iter->next;
> +}
>
> /* Get a pointer to the current UI's line buffer. This is used to
> construct a whole line of input from partial input. */
> diff --git a/gdb/mi/mi-interp.c b/gdb/mi/mi-interp.c
> index 8ba6110..f9820cb 100644
> --- a/gdb/mi/mi-interp.c
> +++ b/gdb/mi/mi-interp.c
> @@ -88,6 +88,17 @@ static void mi_on_sync_execution_done (void);
>
> static int report_initial_inferior (struct inferior *inf, void *closure);
>
> +/* Returns the INTERP's data cast as mi_interp if INTERP is an MI, and
> + returns NULL otherwise. */
> +
> +static struct mi_interp *
> +as_mi_interp (struct interp *interp)
> +{
> + if (ui_out_is_mi_like_p (interp_ui_out (interp)))
> + return (struct mi_interp *) interp_data (interp);
> + return NULL;
> +}
> +
> static void *
> mi_interpreter_init (struct interp *interp, int top_level)
> {
> @@ -127,39 +138,8 @@ mi_interpreter_init (struct interp *interp, int top_level)
> mi->mi_uiout = mi_out_new (mi_version);
> mi->cli_uiout = cli_out_new (mi->out);
>
> - /* There are installed even if MI is not the top level interpreter.
> - The callbacks themselves decide whether to be skipped. */
> - observer_attach_signal_received (mi_on_signal_received);
> - observer_attach_end_stepping_range (mi_on_end_stepping_range);
> - observer_attach_signal_exited (mi_on_signal_exited);
> - observer_attach_exited (mi_on_exited);
> - observer_attach_no_history (mi_on_no_history);
> -
> if (top_level)
> {
> - observer_attach_new_thread (mi_new_thread);
> - observer_attach_thread_exit (mi_thread_exit);
> - observer_attach_inferior_added (mi_inferior_added);
> - observer_attach_inferior_appeared (mi_inferior_appeared);
> - observer_attach_inferior_exit (mi_inferior_exit);
> - observer_attach_inferior_removed (mi_inferior_removed);
> - observer_attach_record_changed (mi_record_changed);
> - observer_attach_normal_stop (mi_on_normal_stop);
> - observer_attach_target_resumed (mi_on_resume);
> - observer_attach_solib_loaded (mi_solib_loaded);
> - observer_attach_solib_unloaded (mi_solib_unloaded);
> - observer_attach_about_to_proceed (mi_about_to_proceed);
> - observer_attach_traceframe_changed (mi_traceframe_changed);
> - observer_attach_tsv_created (mi_tsv_created);
> - observer_attach_tsv_deleted (mi_tsv_deleted);
> - observer_attach_tsv_modified (mi_tsv_modified);
> - observer_attach_breakpoint_created (mi_breakpoint_created);
> - observer_attach_breakpoint_deleted (mi_breakpoint_deleted);
> - observer_attach_breakpoint_modified (mi_breakpoint_modified);
> - observer_attach_command_param_changed (mi_command_param_changed);
> - observer_attach_memory_changed (mi_memory_changed);
> - observer_attach_sync_execution_done (mi_on_sync_execution_done);
> -
> /* The initial inferior is created before this function is
> called, so we need to report it explicitly. Use iteration in
> case future version of GDB creates more than one inferior
> @@ -311,6 +291,12 @@ mi_execute_command_wrapper (const char *cmd)
> static void
> mi_on_sync_execution_done (void)
> {
> + struct ui *ui = current_ui;
> + struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
> +
> + if (mi == NULL)
> + return;
> +
> /* If MI is sync, then output the MI prompt now, indicating we're
> ready for further input. */
> if (!mi_async_p ())
> @@ -356,45 +342,56 @@ mi_command_loop (void *data)
> static void
> mi_new_thread (struct thread_info *t)
> {
> - struct mi_interp *mi = (struct mi_interp *) top_level_interpreter_data ();
> struct inferior *inf = find_inferior_ptid (t->ptid);
> - struct cleanup *old_chain;
> + struct switch_thru_all_uis state;
>
> gdb_assert (inf);
>
> - old_chain = make_cleanup_restore_target_terminal ();
> - target_terminal_ours_for_output ();
> + SWITCH_THRU_ALL_UIS (state)
> + {
> + struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
> + struct cleanup *old_chain;
>
> - fprintf_unfiltered (mi->event_channel,
> - "thread-created,id=\"%d\",group-id=\"i%d\"",
> - t->global_num, inf->num);
> - gdb_flush (mi->event_channel);
> + if (mi == NULL)
> + continue;
>
> - do_cleanups (old_chain);
> + old_chain = make_cleanup_restore_target_terminal ();
> + target_terminal_ours_for_output ();
> +
> + fprintf_unfiltered (mi->event_channel,
> + "thread-created,id=\"%d\",group-id=\"i%d\"",
> + t->global_num, inf->num);
> + gdb_flush (mi->event_channel);
> +
> + do_cleanups (old_chain);
> + }
> }
>
> static void
> mi_thread_exit (struct thread_info *t, int silent)
> {
> - struct mi_interp *mi;
> - struct inferior *inf;
> - struct cleanup *old_chain;
> + struct switch_thru_all_uis state;
>
> if (silent)
> return;
>
> - inf = find_inferior_ptid (t->ptid);
> + SWITCH_THRU_ALL_UIS (state)
> + {
> + struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
> + struct cleanup *old_chain;
>
> - mi = (struct mi_interp *) top_level_interpreter_data ();
> - old_chain = make_cleanup_restore_target_terminal ();
> - target_terminal_ours_for_output ();
> + if (mi == NULL)
> + continue;
>
> - fprintf_unfiltered (mi->event_channel,
> - "thread-exited,id=\"%d\",group-id=\"i%d\"",
> - t->global_num, inf->num);
> - gdb_flush (mi->event_channel);
> + old_chain = make_cleanup_restore_target_terminal ();
> + target_terminal_ours_for_output ();
> + fprintf_unfiltered (mi->event_channel,
> + "thread-exited,id=\"%d\",group-id=\"i%d\"",
> + t->global_num, t->inf->num);
> + gdb_flush (mi->event_channel);
>
> - do_cleanups (old_chain);
> + do_cleanups (old_chain);
> + }
> }
>
> /* Emit notification on changing the state of record. */
> @@ -402,122 +399,155 @@ mi_thread_exit (struct thread_info *t, int silent)
> static void
> mi_record_changed (struct inferior *inferior, int started)
> {
> - struct mi_interp *mi = (struct mi_interp *) top_level_interpreter_data ();
> - struct cleanup *old_chain;
> + struct switch_thru_all_uis state;
>
> - old_chain = make_cleanup_restore_target_terminal ();
> - target_terminal_ours_for_output ();
> + SWITCH_THRU_ALL_UIS (state)
> + {
> + struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
> + struct cleanup *old_chain;
>
> - fprintf_unfiltered (mi->event_channel, "record-%s,thread-group=\"i%d\"",
> - started ? "started" : "stopped", inferior->num);
> + if (mi == NULL)
> + continue;
>
> - gdb_flush (mi->event_channel);
> + old_chain = make_cleanup_restore_target_terminal ();
> + target_terminal_ours_for_output ();
>
> - do_cleanups (old_chain);
> + fprintf_unfiltered (mi->event_channel, "record-%s,thread-group=\"i%d\"",
> + started ? "started" : "stopped", inferior->num);
> + gdb_flush (mi->event_channel);
> +
> + do_cleanups (old_chain);
> + }
> }
>
> static void
> mi_inferior_added (struct inferior *inf)
> {
> - struct mi_interp *mi = (struct mi_interp *) top_level_interpreter_data ();
> - struct cleanup *old_chain;
> + struct switch_thru_all_uis state;
>
> - old_chain = make_cleanup_restore_target_terminal ();
> - target_terminal_ours_for_output ();
> + SWITCH_THRU_ALL_UIS (state)
> + {
> + struct interp *interp;
> + struct mi_interp *mi;
> + struct cleanup *old_chain;
>
> - fprintf_unfiltered (mi->event_channel,
> - "thread-group-added,id=\"i%d\"",
> - inf->num);
> - gdb_flush (mi->event_channel);
> + /* We'll be called once for the initial inferior, before the top
> + level interpreter is set. */
> + interp = top_level_interpreter ();
> + if (interp == NULL)
> + continue;
>
> - do_cleanups (old_chain);
> + mi = as_mi_interp (interp);
> + if (mi == NULL)
> + continue;
> +
> + old_chain = make_cleanup_restore_target_terminal ();
> + target_terminal_ours_for_output ();
> +
> + fprintf_unfiltered (mi->event_channel,
> + "thread-group-added,id=\"i%d\"",
> + inf->num);
> + gdb_flush (mi->event_channel);
> +
> + do_cleanups (old_chain);
> + }
> }
>
> static void
> mi_inferior_appeared (struct inferior *inf)
> {
> - struct mi_interp *mi = (struct mi_interp *) top_level_interpreter_data ();
> - struct cleanup *old_chain;
> + struct switch_thru_all_uis state;
>
> - old_chain = make_cleanup_restore_target_terminal ();
> - target_terminal_ours_for_output ();
> + SWITCH_THRU_ALL_UIS (state)
> + {
> + struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
> + struct cleanup *old_chain;
>
> - fprintf_unfiltered (mi->event_channel,
> - "thread-group-started,id=\"i%d\",pid=\"%d\"",
> - inf->num, inf->pid);
> - gdb_flush (mi->event_channel);
> + if (mi == NULL)
> + continue;
>
> - do_cleanups (old_chain);
> + old_chain = make_cleanup_restore_target_terminal ();
> + target_terminal_ours_for_output ();
> +
> + fprintf_unfiltered (mi->event_channel,
> + "thread-group-started,id=\"i%d\",pid=\"%d\"",
> + inf->num, inf->pid);
> + gdb_flush (mi->event_channel);
> + do_cleanups (old_chain);
> + }
> }
>
> static void
> mi_inferior_exit (struct inferior *inf)
> {
> - struct mi_interp *mi = (struct mi_interp *) top_level_interpreter_data ();
> - struct cleanup *old_chain;
> + struct switch_thru_all_uis state;
>
> - old_chain = make_cleanup_restore_target_terminal ();
> - target_terminal_ours_for_output ();
> + SWITCH_THRU_ALL_UIS (state)
> + {
> + struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
> + struct cleanup *old_chain;
>
> - if (inf->has_exit_code)
> - fprintf_unfiltered (mi->event_channel,
> - "thread-group-exited,id=\"i%d\",exit-code=\"%s\"",
> - inf->num, int_string (inf->exit_code, 8, 0, 0, 1));
> - else
> - fprintf_unfiltered (mi->event_channel,
> - "thread-group-exited,id=\"i%d\"", inf->num);
> - gdb_flush (mi->event_channel);
> + if (mi == NULL)
> + continue;
>
> - do_cleanups (old_chain);
> + old_chain = make_cleanup_restore_target_terminal ();
> + target_terminal_ours_for_output ();
> +
> + if (inf->has_exit_code)
> + fprintf_unfiltered (mi->event_channel,
> + "thread-group-exited,id=\"i%d\",exit-code=\"%s\"",
> + inf->num, int_string (inf->exit_code, 8, 0, 0, 1));
> + else
> + fprintf_unfiltered (mi->event_channel,
> + "thread-group-exited,id=\"i%d\"", inf->num);
> +
> + gdb_flush (mi->event_channel);
> + do_cleanups (old_chain);
> + }
> }
>
> static void
> mi_inferior_removed (struct inferior *inf)
> {
> - struct mi_interp *mi = (struct mi_interp *) top_level_interpreter_data ();
> - struct cleanup *old_chain;
> + struct switch_thru_all_uis state;
>
> - old_chain = make_cleanup_restore_target_terminal ();
> - target_terminal_ours_for_output ();
> + SWITCH_THRU_ALL_UIS (state)
> + {
> + struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
> + struct cleanup *old_chain;
>
> - fprintf_unfiltered (mi->event_channel,
> - "thread-group-removed,id=\"i%d\"",
> - inf->num);
> - gdb_flush (mi->event_channel);
> + if (mi == NULL)
> + continue;
>
> - do_cleanups (old_chain);
> + old_chain = make_cleanup_restore_target_terminal ();
> + target_terminal_ours_for_output ();
> +
> + fprintf_unfiltered (mi->event_channel,
> + "thread-group-removed,id=\"i%d\"",
> + inf->num);
> + gdb_flush (mi->event_channel);
> +
> + do_cleanups (old_chain);
> + }
> }
>
> /* Return the MI interpreter, if it is active -- either because it's
> the top-level interpreter or the interpreter executing the current
> command. Returns NULL if the MI interpreter is not being used. */
>
> -static struct interp *
> -find_mi_interpreter (void)
> +static struct mi_interp *
> +find_mi_interp (void)
> {
> - struct interp *interp;
> -
> - interp = top_level_interpreter ();
> - if (ui_out_is_mi_like_p (interp_ui_out (interp)))
> - return interp;
> -
> - interp = command_interp ();
> - if (ui_out_is_mi_like_p (interp_ui_out (interp)))
> - return interp;
> -
> - return NULL;
> -}
> + struct mi_interp *mi;
>
> -/* Return the MI_INTERP structure of the active MI interpreter.
> - Returns NULL if MI is not active. */
> + mi = as_mi_interp (top_level_interpreter ());
> + if (mi != NULL)
> + return mi;
>
> -static struct mi_interp *
> -mi_interp_data (void)
> -{
> - struct interp *interp = find_mi_interpreter ();
> + mi = as_mi_interp (command_interp ());
> + if (mi != NULL)
> + return mi;
>
> - if (interp != NULL)
> - return (struct mi_interp *) interp_data (interp);
> return NULL;
> }
>
> @@ -530,13 +560,18 @@ mi_interp_data (void)
> static void
> mi_on_signal_received (enum gdb_signal siggnal)
> {
> - struct mi_interp *mi = mi_interp_data ();
> + struct switch_thru_all_uis state;
>
> - if (mi == NULL)
> - return;
> + SWITCH_THRU_ALL_UIS (state)
> + {
> + struct mi_interp *mi = find_mi_interp ();
> +
> + if (mi == NULL)
> + continue;
>
> - print_signal_received_reason (mi->mi_uiout, siggnal);
> - print_signal_received_reason (mi->cli_uiout, siggnal);
> + print_signal_received_reason (mi->mi_uiout, siggnal);
> + print_signal_received_reason (mi->cli_uiout, siggnal);
> + }
> }
>
> /* Observer for the end_stepping_range notification. */
> @@ -544,13 +579,18 @@ mi_on_signal_received (enum gdb_signal siggnal)
> static void
> mi_on_end_stepping_range (void)
> {
> - struct mi_interp *mi = mi_interp_data ();
> + struct switch_thru_all_uis state;
>
> - if (mi == NULL)
> - return;
> + SWITCH_THRU_ALL_UIS (state)
> + {
> + struct mi_interp *mi = find_mi_interp ();
> +
> + if (mi == NULL)
> + continue;
>
> - print_end_stepping_range_reason (mi->mi_uiout);
> - print_end_stepping_range_reason (mi->cli_uiout);
> + print_end_stepping_range_reason (mi->mi_uiout);
> + print_end_stepping_range_reason (mi->cli_uiout);
> + }
> }
>
> /* Observer for the signal_exited notification. */
> @@ -558,13 +598,18 @@ mi_on_end_stepping_range (void)
> static void
> mi_on_signal_exited (enum gdb_signal siggnal)
> {
> - struct mi_interp *mi = mi_interp_data ();
> + struct switch_thru_all_uis state;
>
> - if (mi == NULL)
> - return;
> + SWITCH_THRU_ALL_UIS (state)
> + {
> + struct mi_interp *mi = find_mi_interp ();
> +
> + if (mi == NULL)
> + continue;
>
> - print_signal_exited_reason (mi->mi_uiout, siggnal);
> - print_signal_exited_reason (mi->cli_uiout, siggnal);
> + print_signal_exited_reason (mi->mi_uiout, siggnal);
> + print_signal_exited_reason (mi->cli_uiout, siggnal);
> + }
> }
>
> /* Observer for the exited notification. */
> @@ -572,13 +617,18 @@ mi_on_signal_exited (enum gdb_signal siggnal)
> static void
> mi_on_exited (int exitstatus)
> {
> - struct mi_interp *mi = mi_interp_data ();
> + struct switch_thru_all_uis state;
>
> - if (mi == NULL)
> - return;
> + SWITCH_THRU_ALL_UIS (state)
> + {
> + struct mi_interp *mi = find_mi_interp ();
> +
> + if (mi == NULL)
> + continue;
>
> - print_exited_reason (mi->mi_uiout, exitstatus);
> - print_exited_reason (mi->cli_uiout, exitstatus);
> + print_exited_reason (mi->mi_uiout, exitstatus);
> + print_exited_reason (mi->cli_uiout, exitstatus);
> + }
> }
>
> /* Observer for the no_history notification. */
> @@ -586,17 +636,22 @@ mi_on_exited (int exitstatus)
> static void
> mi_on_no_history (void)
> {
> - struct mi_interp *mi = mi_interp_data ();
> + struct switch_thru_all_uis state;
>
> - if (mi == NULL)
> - return;
> + SWITCH_THRU_ALL_UIS (state)
> + {
> + struct mi_interp *mi = find_mi_interp ();
> +
> + if (mi == NULL)
> + continue;
>
> - print_no_history_reason (mi->mi_uiout);
> - print_no_history_reason (mi->cli_uiout);
> + print_no_history_reason (mi->mi_uiout);
> + print_no_history_reason (mi->cli_uiout);
> + }
> }
>
> static void
> -mi_on_normal_stop (struct bpstats *bs, int print_frame)
> +mi_on_normal_stop_1 (struct bpstats *bs, int print_frame)
> {
> /* Since this can be called when CLI command is executing,
> using cli interpreter, be sure to use MI uiout for output,
> @@ -677,6 +732,20 @@ mi_on_normal_stop (struct bpstats *bs, int print_frame)
> }
>
> static void
> +mi_on_normal_stop (struct bpstats *bs, int print_frame)
> +{
> + struct switch_thru_all_uis state;
> +
> + SWITCH_THRU_ALL_UIS (state)
> + {
> + if (as_mi_interp (top_level_interpreter ()) == NULL)
> + continue;
> +
> + mi_on_normal_stop_1 (bs, print_frame);
> + }
> +}
> +
> +static void
> mi_about_to_proceed (void)
> {
> /* Suppress output while calling an inferior function. */
> @@ -707,25 +776,33 @@ struct mi_suppress_notification mi_suppress_notification =
> static void
> mi_traceframe_changed (int tfnum, int tpnum)
> {
> - struct mi_interp *mi = (struct mi_interp *) top_level_interpreter_data ();
> - struct cleanup *old_chain;
> + struct switch_thru_all_uis state;
>
> if (mi_suppress_notification.traceframe)
> return;
>
> - old_chain = make_cleanup_restore_target_terminal ();
> - target_terminal_ours_for_output ();
> + SWITCH_THRU_ALL_UIS (state)
> + {
> + struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
> + struct cleanup *old_chain;
>
> - if (tfnum >= 0)
> - fprintf_unfiltered (mi->event_channel, "traceframe-changed,"
> - "num=\"%d\",tracepoint=\"%d\"\n",
> - tfnum, tpnum);
> - else
> - fprintf_unfiltered (mi->event_channel, "traceframe-changed,end");
> + if (mi == NULL)
> + continue;
>
> - gdb_flush (mi->event_channel);
> + old_chain = make_cleanup_restore_target_terminal ();
> + target_terminal_ours_for_output ();
>
> - do_cleanups (old_chain);
> + if (tfnum >= 0)
> + fprintf_unfiltered (mi->event_channel, "traceframe-changed,"
> + "num=\"%d\",tracepoint=\"%d\"\n",
> + tfnum, tpnum);
> + else
> + fprintf_unfiltered (mi->event_channel, "traceframe-changed,end");
> +
> + gdb_flush (mi->event_channel);
> +
> + do_cleanups (old_chain);
> + }
> }
>
> /* Emit notification on creating a trace state variable. */
> @@ -733,19 +810,27 @@ mi_traceframe_changed (int tfnum, int tpnum)
> static void
> mi_tsv_created (const struct trace_state_variable *tsv)
> {
> - struct mi_interp *mi = (struct mi_interp *) top_level_interpreter_data ();
> - struct cleanup *old_chain;
> + struct switch_thru_all_uis state;
>
> - old_chain = make_cleanup_restore_target_terminal ();
> - target_terminal_ours_for_output ();
> + SWITCH_THRU_ALL_UIS (state)
> + {
> + struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
> + struct cleanup *old_chain;
>
> - fprintf_unfiltered (mi->event_channel, "tsv-created,"
> - "name=\"%s\",initial=\"%s\"\n",
> - tsv->name, plongest (tsv->initial_value));
> + if (mi == NULL)
> + continue;
>
> - gdb_flush (mi->event_channel);
> + old_chain = make_cleanup_restore_target_terminal ();
> + target_terminal_ours_for_output ();
>
> - do_cleanups (old_chain);
> + fprintf_unfiltered (mi->event_channel, "tsv-created,"
> + "name=\"%s\",initial=\"%s\"\n",
> + tsv->name, plongest (tsv->initial_value));
> +
> + gdb_flush (mi->event_channel);
> +
> + do_cleanups (old_chain);
> + }
> }
>
> /* Emit notification on deleting a trace state variable. */
> @@ -753,21 +838,29 @@ mi_tsv_created (const struct trace_state_variable *tsv)
> static void
> mi_tsv_deleted (const struct trace_state_variable *tsv)
> {
> - struct mi_interp *mi = (struct mi_interp *) top_level_interpreter_data ();
> - struct cleanup *old_chain;
> + struct switch_thru_all_uis state;
>
> - old_chain = make_cleanup_restore_target_terminal ();
> - target_terminal_ours_for_output ();
> + SWITCH_THRU_ALL_UIS (state)
> + {
> + struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
> + struct cleanup *old_chain;
>
> - if (tsv != NULL)
> - fprintf_unfiltered (mi->event_channel, "tsv-deleted,"
> - "name=\"%s\"\n", tsv->name);
> - else
> - fprintf_unfiltered (mi->event_channel, "tsv-deleted\n");
> + if (mi == NULL)
> + continue;
>
> - gdb_flush (mi->event_channel);
> + old_chain = make_cleanup_restore_target_terminal ();
> + target_terminal_ours_for_output ();
>
> - do_cleanups (old_chain);
> + if (tsv != NULL)
> + fprintf_unfiltered (mi->event_channel, "tsv-deleted,"
> + "name=\"%s\"\n", tsv->name);
> + else
> + fprintf_unfiltered (mi->event_channel, "tsv-deleted\n");
> +
> + gdb_flush (mi->event_channel);
> +
> + do_cleanups (old_chain);
> + }
> }
>
> /* Emit notification on modifying a trace state variable. */
> @@ -775,29 +868,39 @@ mi_tsv_deleted (const struct trace_state_variable *tsv)
> static void
> mi_tsv_modified (const struct trace_state_variable *tsv)
> {
> - struct mi_interp *mi = (struct mi_interp *) top_level_interpreter_data ();
> - struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
> - struct cleanup *old_chain;
> + struct switch_thru_all_uis state;
>
> - old_chain = make_cleanup_restore_target_terminal ();
> - target_terminal_ours_for_output ();
> + SWITCH_THRU_ALL_UIS (state)
> + {
> + struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
> + struct ui_out *mi_uiout;
> + struct cleanup *old_chain;
>
> - fprintf_unfiltered (mi->event_channel,
> - "tsv-modified");
> + if (mi == NULL)
> + continue;
>
> - ui_out_redirect (mi_uiout, mi->event_channel);
> + mi_uiout = interp_ui_out (top_level_interpreter ());
>
> - ui_out_field_string (mi_uiout, "name", tsv->name);
> - ui_out_field_string (mi_uiout, "initial",
> - plongest (tsv->initial_value));
> - if (tsv->value_known)
> - ui_out_field_string (mi_uiout, "current", plongest (tsv->value));
> + old_chain = make_cleanup_restore_target_terminal ();
> + target_terminal_ours_for_output ();
>
> - ui_out_redirect (mi_uiout, NULL);
> + fprintf_unfiltered (mi->event_channel,
> + "tsv-modified");
>
> - gdb_flush (mi->event_channel);
> + ui_out_redirect (mi_uiout, mi->event_channel);
>
> - do_cleanups (old_chain);
> + ui_out_field_string (mi_uiout, "name", tsv->name);
> + ui_out_field_string (mi_uiout, "initial",
> + plongest (tsv->initial_value));
> + if (tsv->value_known)
> + ui_out_field_string (mi_uiout, "current", plongest (tsv->value));
> +
> + ui_out_redirect (mi_uiout, NULL);
> +
> + gdb_flush (mi->event_channel);
> +
> + do_cleanups (old_chain);
> + }
> }
>
> /* Emit notification about a created breakpoint. */
> @@ -805,9 +908,7 @@ mi_tsv_modified (const struct trace_state_variable *tsv)
> static void
> mi_breakpoint_created (struct breakpoint *b)
> {
> - struct mi_interp *mi = (struct mi_interp *) top_level_interpreter_data ();
> - struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
> - struct cleanup *old_chain;
> + struct switch_thru_all_uis state;
>
> if (mi_suppress_notification.breakpoint)
> return;
> @@ -815,33 +916,45 @@ mi_breakpoint_created (struct breakpoint *b)
> if (b->number <= 0)
> return;
>
> - old_chain = make_cleanup_restore_target_terminal ();
> - target_terminal_ours_for_output ();
> -
> - fprintf_unfiltered (mi->event_channel,
> - "breakpoint-created");
> - /* We want the output from gdb_breakpoint_query to go to
> - mi->event_channel. One approach would be to just call
> - gdb_breakpoint_query, and then use mi_out_put to send the current
> - content of mi_outout into mi->event_channel. However, that will
> - break if anything is output to mi_uiout prior to calling the
> - breakpoint_created notifications. So, we use
> - ui_out_redirect. */
> - ui_out_redirect (mi_uiout, mi->event_channel);
> - TRY
> + SWITCH_THRU_ALL_UIS (state)
> {
> - gdb_breakpoint_query (mi_uiout, b->number, NULL);
> - }
> - CATCH (e, RETURN_MASK_ERROR)
> - {
> - }
> - END_CATCH
> + struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
> + struct ui_out *mi_uiout;
> + struct cleanup *old_chain;
> +
> + if (mi == NULL)
> + continue;
> +
> + mi_uiout = interp_ui_out (top_level_interpreter ());
> +
> + old_chain = make_cleanup_restore_target_terminal ();
> + target_terminal_ours_for_output ();
> +
> + fprintf_unfiltered (mi->event_channel,
> + "breakpoint-created");
> + /* We want the output from gdb_breakpoint_query to go to
> + mi->event_channel. One approach would be to just call
> + gdb_breakpoint_query, and then use mi_out_put to send the current
> + content of mi_outout into mi->event_channel. However, that will
> + break if anything is output to mi_uiout prior to calling the
> + breakpoint_created notifications. So, we use
> + ui_out_redirect. */
> + ui_out_redirect (mi_uiout, mi->event_channel);
> + TRY
> + {
> + gdb_breakpoint_query (mi_uiout, b->number, NULL);
> + }
> + CATCH (e, RETURN_MASK_ERROR)
> + {
> + }
> + END_CATCH
>
> - ui_out_redirect (mi_uiout, NULL);
> + ui_out_redirect (mi_uiout, NULL);
>
> - gdb_flush (mi->event_channel);
> + gdb_flush (mi->event_channel);
>
> - do_cleanups (old_chain);
> + do_cleanups (old_chain);
> + }
> }
>
> /* Emit notification about deleted breakpoint. */
> @@ -849,8 +962,7 @@ mi_breakpoint_created (struct breakpoint *b)
> static void
> mi_breakpoint_deleted (struct breakpoint *b)
> {
> - struct mi_interp *mi = (struct mi_interp *) top_level_interpreter_data ();
> - struct cleanup *old_chain;
> + struct switch_thru_all_uis state;
>
> if (mi_suppress_notification.breakpoint)
> return;
> @@ -858,15 +970,24 @@ mi_breakpoint_deleted (struct breakpoint *b)
> if (b->number <= 0)
> return;
>
> - old_chain = make_cleanup_restore_target_terminal ();
> - target_terminal_ours_for_output ();
> + SWITCH_THRU_ALL_UIS (state)
> + {
> + struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
> + struct cleanup *old_chain;
>
> - fprintf_unfiltered (mi->event_channel, "breakpoint-deleted,id=\"%d\"",
> - b->number);
> + if (mi == NULL)
> + continue;
>
> - gdb_flush (mi->event_channel);
> + old_chain = make_cleanup_restore_target_terminal ();
> + target_terminal_ours_for_output ();
>
> - do_cleanups (old_chain);
> + fprintf_unfiltered (mi->event_channel, "breakpoint-deleted,id=\"%d\"",
> + b->number);
> +
> + gdb_flush (mi->event_channel);
> +
> + do_cleanups (old_chain);
> + }
> }
>
> /* Emit notification about modified breakpoint. */
> @@ -874,9 +995,7 @@ mi_breakpoint_deleted (struct breakpoint *b)
> static void
> mi_breakpoint_modified (struct breakpoint *b)
> {
> - struct mi_interp *mi = (struct mi_interp *) top_level_interpreter_data ();
> - struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
> - struct cleanup *old_chain;
> + struct switch_thru_all_uis state;
>
> if (mi_suppress_notification.breakpoint)
> return;
> @@ -884,44 +1003,61 @@ mi_breakpoint_modified (struct breakpoint *b)
> if (b->number <= 0)
> return;
>
> - old_chain = make_cleanup_restore_target_terminal ();
> - target_terminal_ours_for_output ();
> -
> - fprintf_unfiltered (mi->event_channel,
> - "breakpoint-modified");
> - /* We want the output from gdb_breakpoint_query to go to
> - mi->event_channel. One approach would be to just call
> - gdb_breakpoint_query, and then use mi_out_put to send the current
> - content of mi_outout into mi->event_channel. However, that will
> - break if anything is output to mi_uiout prior to calling the
> - breakpoint_created notifications. So, we use
> - ui_out_redirect. */
> - ui_out_redirect (mi_uiout, mi->event_channel);
> - TRY
> + SWITCH_THRU_ALL_UIS (state)
> {
> - gdb_breakpoint_query (mi_uiout, b->number, NULL);
> - }
> - CATCH (e, RETURN_MASK_ERROR)
> - {
> - }
> - END_CATCH
> + struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
> + struct cleanup *old_chain;
> +
> + if (mi == NULL)
> + continue;
> +
> + old_chain = make_cleanup_restore_target_terminal ();
> + target_terminal_ours_for_output ();
> + fprintf_unfiltered (mi->event_channel,
> + "breakpoint-modified");
> + /* We want the output from gdb_breakpoint_query to go to
> + mi->event_channel. One approach would be to just call
> + gdb_breakpoint_query, and then use mi_out_put to send the current
> + content of mi_outout into mi->event_channel. However, that will
> + break if anything is output to mi_uiout prior to calling the
> + breakpoint_created notifications. So, we use
> + ui_out_redirect. */
> + ui_out_redirect (mi->mi_uiout, mi->event_channel);
> + TRY
> + {
> + gdb_breakpoint_query (mi->mi_uiout, b->number, NULL);
> + }
> + CATCH (e, RETURN_MASK_ERROR)
> + {
> + }
> + END_CATCH
>
> - ui_out_redirect (mi_uiout, NULL);
> + ui_out_redirect (mi->mi_uiout, NULL);
>
> - gdb_flush (mi->event_channel);
> + gdb_flush (mi->event_channel);
>
> - do_cleanups (old_chain);
> + do_cleanups (old_chain);
> + }
> }
>
> static int
> mi_output_running_pid (struct thread_info *info, void *arg)
> {
> ptid_t *ptid = (ptid_t *) arg;
> + struct switch_thru_all_uis state;
>
> - if (ptid_get_pid (*ptid) == ptid_get_pid (info->ptid))
> - fprintf_unfiltered (raw_stdout,
> - "*running,thread-id=\"%d\"\n",
> - info->global_num);
> + SWITCH_THRU_ALL_UIS (state)
> + {
> + struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
> +
> + if (mi == NULL)
> + continue;
> +
> + if (ptid_get_pid (*ptid) == ptid_get_pid (info->ptid))
> + fprintf_unfiltered (raw_stdout,
> + "*running,thread-id=\"%d\"\n",
> + info->global_num);
> + }
>
> return 0;
> }
> @@ -939,19 +1075,8 @@ mi_inferior_count (struct inferior *inf, void *arg)
> }
>
> static void
> -mi_on_resume (ptid_t ptid)
> +mi_on_resume_1 (ptid_t ptid)
> {
> - struct thread_info *tp = NULL;
> -
> - if (ptid_equal (ptid, minus_one_ptid) || ptid_is_pid (ptid))
> - tp = inferior_thread ();
> - else
> - tp = find_thread_ptid (ptid);
> -
> - /* Suppress output while calling an inferior function. */
> - if (tp->control.in_infcall)
> - return;
> -
> /* To cater for older frontends, emit ^running, but do it only once
> per each command. We do it here, since at this point we know
> that the target was successfully resumed, and in non-async mode,
> @@ -1006,64 +1131,116 @@ mi_on_resume (ptid_t ptid)
> }
>
> static void
> -mi_solib_loaded (struct so_list *solib)
> +mi_on_resume (ptid_t ptid)
> {
> - struct mi_interp *mi = (struct mi_interp *) top_level_interpreter_data ();
> - struct ui_out *uiout = interp_ui_out (top_level_interpreter ());
> - struct cleanup *old_chain;
> -
> - old_chain = make_cleanup_restore_target_terminal ();
> - target_terminal_ours_for_output ();
> + struct thread_info *tp = NULL;
> + struct switch_thru_all_uis state;
>
> - fprintf_unfiltered (mi->event_channel, "library-loaded");
> + if (ptid_equal (ptid, minus_one_ptid) || ptid_is_pid (ptid))
> + tp = inferior_thread ();
> + else
> + tp = find_thread_ptid (ptid);
>
> - ui_out_redirect (uiout, mi->event_channel);
> + /* Suppress output while calling an inferior function. */
> + if (tp->control.in_infcall)
> + return;
>
> - ui_out_field_string (uiout, "id", solib->so_original_name);
> - ui_out_field_string (uiout, "target-name", solib->so_original_name);
> - ui_out_field_string (uiout, "host-name", solib->so_name);
> - ui_out_field_int (uiout, "symbols-loaded", solib->symbols_loaded);
> - if (!gdbarch_has_global_solist (target_gdbarch ()))
> + SWITCH_THRU_ALL_UIS (state)
> {
> - ui_out_field_fmt (uiout, "thread-group", "i%d",
> - current_inferior ()->num);
> + struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
> + struct cleanup *old_chain;
> +
> + if (mi == NULL)
> + continue;
> +
> + old_chain = make_cleanup_restore_target_terminal ();
> + target_terminal_ours_for_output ();
> +
> + mi_on_resume_1 (ptid);
> +
> + do_cleanups (old_chain);
> }
> +}
>
> - ui_out_redirect (uiout, NULL);
> +static void
> +mi_solib_loaded (struct so_list *solib)
> +{
> + struct switch_thru_all_uis state;
>
> - gdb_flush (mi->event_channel);
> + SWITCH_THRU_ALL_UIS (state)
> + {
> + struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
> + struct ui_out *uiout;
> + struct cleanup *old_chain;
>
> - do_cleanups (old_chain);
> + if (mi == NULL)
> + continue;
> +
> + uiout = interp_ui_out (top_level_interpreter ());
> +
> + old_chain = make_cleanup_restore_target_terminal ();
> + target_terminal_ours_for_output ();
> +
> + fprintf_unfiltered (mi->event_channel, "library-loaded");
> +
> + ui_out_redirect (uiout, mi->event_channel);
> +
> + ui_out_field_string (uiout, "id", solib->so_original_name);
> + ui_out_field_string (uiout, "target-name", solib->so_original_name);
> + ui_out_field_string (uiout, "host-name", solib->so_name);
> + ui_out_field_int (uiout, "symbols-loaded", solib->symbols_loaded);
> + if (!gdbarch_has_global_solist (target_gdbarch ()))
> + {
> + ui_out_field_fmt (uiout, "thread-group", "i%d",
> + current_inferior ()->num);
> + }
> +
> + ui_out_redirect (uiout, NULL);
> +
> + gdb_flush (mi->event_channel);
> +
> + do_cleanups (old_chain);
> + }
> }
>
> static void
> mi_solib_unloaded (struct so_list *solib)
> {
> - struct mi_interp *mi = (struct mi_interp *) top_level_interpreter_data ();
> - struct ui_out *uiout = interp_ui_out (top_level_interpreter ());
> - struct cleanup *old_chain;
> + struct switch_thru_all_uis state;
>
> - old_chain = make_cleanup_restore_target_terminal ();
> - target_terminal_ours_for_output ();
> + SWITCH_THRU_ALL_UIS (state)
> + {
> + struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
> + struct ui_out *uiout;
> + struct cleanup *old_chain;
>
> - fprintf_unfiltered (mi->event_channel, "library-unloaded");
> + if (mi == NULL)
> + continue;
>
> - ui_out_redirect (uiout, mi->event_channel);
> + uiout = interp_ui_out (top_level_interpreter ());
>
> - ui_out_field_string (uiout, "id", solib->so_original_name);
> - ui_out_field_string (uiout, "target-name", solib->so_original_name);
> - ui_out_field_string (uiout, "host-name", solib->so_name);
> - if (!gdbarch_has_global_solist (target_gdbarch ()))
> - {
> - ui_out_field_fmt (uiout, "thread-group", "i%d",
> - current_inferior ()->num);
> - }
> + old_chain = make_cleanup_restore_target_terminal ();
> + target_terminal_ours_for_output ();
>
> - ui_out_redirect (uiout, NULL);
> + fprintf_unfiltered (mi->event_channel, "library-unloaded");
>
> - gdb_flush (mi->event_channel);
> + ui_out_redirect (uiout, mi->event_channel);
>
> - do_cleanups (old_chain);
> + ui_out_field_string (uiout, "id", solib->so_original_name);
> + ui_out_field_string (uiout, "target-name", solib->so_original_name);
> + ui_out_field_string (uiout, "host-name", solib->so_name);
> + if (!gdbarch_has_global_solist (target_gdbarch ()))
> + {
> + ui_out_field_fmt (uiout, "thread-group", "i%d",
> + current_inferior ()->num);
> + }
> +
> + ui_out_redirect (uiout, NULL);
> +
> + gdb_flush (mi->event_channel);
> +
> + do_cleanups (old_chain);
> + }
> }
>
> /* Emit notification about the command parameter change. */
> @@ -1071,29 +1248,38 @@ mi_solib_unloaded (struct so_list *solib)
> static void
> mi_command_param_changed (const char *param, const char *value)
> {
> - struct mi_interp *mi = (struct mi_interp *) top_level_interpreter_data ();
> - struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
> - struct cleanup *old_chain;
> + struct switch_thru_all_uis state;
>
> if (mi_suppress_notification.cmd_param_changed)
> return;
>
> - old_chain = make_cleanup_restore_target_terminal ();
> - target_terminal_ours_for_output ();
> + SWITCH_THRU_ALL_UIS (state)
> + {
> + struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
> + struct ui_out *mi_uiout;
> + struct cleanup *old_chain;
>
> - fprintf_unfiltered (mi->event_channel,
> - "cmd-param-changed");
> + if (mi == NULL)
> + continue;
>
> - ui_out_redirect (mi_uiout, mi->event_channel);
> + mi_uiout = interp_ui_out (top_level_interpreter ());
>
> - ui_out_field_string (mi_uiout, "param", param);
> - ui_out_field_string (mi_uiout, "value", value);
> + old_chain = make_cleanup_restore_target_terminal ();
> + target_terminal_ours_for_output ();
>
> - ui_out_redirect (mi_uiout, NULL);
> + fprintf_unfiltered (mi->event_channel, "cmd-param-changed");
>
> - gdb_flush (mi->event_channel);
> + ui_out_redirect (mi_uiout, mi->event_channel);
>
> - do_cleanups (old_chain);
> + ui_out_field_string (mi_uiout, "param", param);
> + ui_out_field_string (mi_uiout, "value", value);
> +
> + ui_out_redirect (mi_uiout, NULL);
> +
> + gdb_flush (mi->event_channel);
> +
> + do_cleanups (old_chain);
> + }
> }
>
> /* Emit notification about the target memory change. */
> @@ -1102,49 +1288,58 @@ static void
> mi_memory_changed (struct inferior *inferior, CORE_ADDR memaddr,
> ssize_t len, const bfd_byte *myaddr)
> {
> - struct mi_interp *mi = (struct mi_interp *) top_level_interpreter_data ();
> - struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
> - struct obj_section *sec;
> - struct cleanup *old_chain;
> + struct switch_thru_all_uis state;
>
> if (mi_suppress_notification.memory)
> return;
>
> - old_chain = make_cleanup_restore_target_terminal ();
> - target_terminal_ours_for_output ();
> + SWITCH_THRU_ALL_UIS (state)
> + {
> + struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
> + struct ui_out *mi_uiout;
> + struct obj_section *sec;
> + struct cleanup *old_chain;
>
> - fprintf_unfiltered (mi->event_channel,
> - "memory-changed");
> + if (mi == NULL)
> + continue;
>
> - ui_out_redirect (mi_uiout, mi->event_channel);
> + mi_uiout = interp_ui_out (top_level_interpreter ());
>
> - ui_out_field_fmt (mi_uiout, "thread-group", "i%d", inferior->num);
> - ui_out_field_core_addr (mi_uiout, "addr", target_gdbarch (), memaddr);
> - ui_out_field_fmt (mi_uiout, "len", "%s", hex_string (len));
> + old_chain = make_cleanup_restore_target_terminal ();
> + target_terminal_ours_for_output ();
>
> - /* Append 'type=code' into notification if MEMADDR falls in the range of
> - sections contain code. */
> - sec = find_pc_section (memaddr);
> - if (sec != NULL && sec->objfile != NULL)
> - {
> - flagword flags = bfd_get_section_flags (sec->objfile->obfd,
> - sec->the_bfd_section);
> + fprintf_unfiltered (mi->event_channel, "memory-changed");
>
> - if (flags & SEC_CODE)
> - ui_out_field_string (mi_uiout, "type", "code");
> - }
> + ui_out_redirect (mi_uiout, mi->event_channel);
>
> - ui_out_redirect (mi_uiout, NULL);
> + ui_out_field_fmt (mi_uiout, "thread-group", "i%d", inferior->num);
> + ui_out_field_core_addr (mi_uiout, "addr", target_gdbarch (), memaddr);
> + ui_out_field_fmt (mi_uiout, "len", "%s", hex_string (len));
>
> - gdb_flush (mi->event_channel);
> + /* Append 'type=code' into notification if MEMADDR falls in the range of
> + sections contain code. */
> + sec = find_pc_section (memaddr);
> + if (sec != NULL && sec->objfile != NULL)
> + {
> + flagword flags = bfd_get_section_flags (sec->objfile->obfd,
> + sec->the_bfd_section);
>
> - do_cleanups (old_chain);
> + if (flags & SEC_CODE)
> + ui_out_field_string (mi_uiout, "type", "code");
> + }
> +
> + ui_out_redirect (mi_uiout, NULL);
> +
> + gdb_flush (mi->event_channel);
> +
> + do_cleanups (old_chain);
> + }
> }
>
> static int
> report_initial_inferior (struct inferior *inf, void *closure)
> {
> - /* This function is called from mi_intepreter_init, and since
> + /* This function is called from mi_interpreter_init, and since
> mi_inferior_added assumes that inferior is fully initialized
> and top_level_interpreter_data is set, we cannot call
> it here. */
> @@ -1250,4 +1445,32 @@ _initialize_mi_interp (void)
> interp_factory_register (INTERP_MI2, mi_interp_factory);
> interp_factory_register (INTERP_MI3, mi_interp_factory);
> interp_factory_register (INTERP_MI, mi_interp_factory);
> +
> + observer_attach_signal_received (mi_on_signal_received);
> + observer_attach_end_stepping_range (mi_on_end_stepping_range);
> + observer_attach_signal_exited (mi_on_signal_exited);
> + observer_attach_exited (mi_on_exited);
> + observer_attach_no_history (mi_on_no_history);
> + observer_attach_new_thread (mi_new_thread);
> + observer_attach_thread_exit (mi_thread_exit);
> + observer_attach_inferior_added (mi_inferior_added);
> + observer_attach_inferior_appeared (mi_inferior_appeared);
> + observer_attach_inferior_exit (mi_inferior_exit);
> + observer_attach_inferior_removed (mi_inferior_removed);
> + observer_attach_record_changed (mi_record_changed);
> + observer_attach_normal_stop (mi_on_normal_stop);
> + observer_attach_target_resumed (mi_on_resume);
> + observer_attach_solib_loaded (mi_solib_loaded);
> + observer_attach_solib_unloaded (mi_solib_unloaded);
> + observer_attach_about_to_proceed (mi_about_to_proceed);
> + observer_attach_traceframe_changed (mi_traceframe_changed);
> + observer_attach_tsv_created (mi_tsv_created);
> + observer_attach_tsv_deleted (mi_tsv_deleted);
> + observer_attach_tsv_modified (mi_tsv_modified);
> + observer_attach_breakpoint_created (mi_breakpoint_created);
> + observer_attach_breakpoint_deleted (mi_breakpoint_deleted);
> + observer_attach_breakpoint_modified (mi_breakpoint_modified);
> + observer_attach_command_param_changed (mi_command_param_changed);
> + observer_attach_memory_changed (mi_memory_changed);
> + observer_attach_sync_execution_done (mi_on_sync_execution_done);
> }
> diff --git a/gdb/top.h b/gdb/top.h
> index f18b79e..805022f 100644
> --- a/gdb/top.h
> +++ b/gdb/top.h
> @@ -36,6 +36,9 @@ struct tl_interp_info;
>
> struct ui
> {
> + /* Pointer to next in singly-linked list. */
> + struct ui *next;
> +
> /* The UI's command line buffer. This is to used to accumulate
> input until we have a whole command line. */
> struct buffer line_buffer;
> @@ -83,8 +86,34 @@ struct ui
> struct ui_file *m_gdb_stdlog;
> };
>
> +/* The current UI. */
> extern struct ui *current_ui;
>
> +/* The list of all UIs. */
> +extern struct ui *ui_list;
> +
> +/* State for SWITCH_THRU_ALL_UIS. Declared here because it is meant
> + to be created on the stack, but should be treated as opaque. */
> +struct switch_thru_all_uis
> +{
> + struct ui *iter;
> + struct cleanup *old_chain;
> +};
> +
> +/* Functions to drive SWITCH_THRU_ALL_UIS. Though declared here by
> + necessity, these functions should not be used other than via the
> + SWITCH_THRU_ALL_UIS macro defined below. */
> +extern void switch_thru_all_uis_init (struct switch_thru_all_uis *state);
> +extern int switch_thru_all_uis_cond (struct switch_thru_all_uis *state);
> +extern void switch_thru_all_uis_next (struct switch_thru_all_uis *state);
> +
> + /* Traverse through all UI, and switch the current UI to the one
> + being iterated. */
> +#define SWITCH_THRU_ALL_UIS(STATE) \
> + for (switch_thru_all_uis_init (&STATE); \
> + switch_thru_all_uis_cond (&STATE); \
> + switch_thru_all_uis_next (&STATE)) \

The last backslash is not necessary I think.

I was wondering why you did not name this "ALL_UIS", using the same pattern
as ALL_INFERIORS & al, but then I realized it's because this one actually
sets current_ui before each iteration (and restores it at the end).

I guess the reason you need to do this is because, again, everything relies on
accessing the global current_ui, whereas it should be passed down as a parameter.
I am not saying it should be done in this series (it's a big task in itself), but
we can probably tackle it after. They way you did things should make it easy to
improve things later on.