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

[Simon Marchi <simon.marchi@ericsson.com>]

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.