gdb/mi/mi-interp.c

   1 /* MI Interpreter Definitions and Commands for GDB, the GNU debugger.
   2
   3    Copyright (C) 2002-2017 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21 #include "interps.h"
  22 #include "event-top.h"
  23 #include "event-loop.h"
  24 #include "inferior.h"
  25 #include "infrun.h"
  26 #include "ui-out.h"
  27 #include "top.h"
  28 #include "mi-main.h"
  29 #include "mi-cmds.h"
  30 #include "mi-out.h"
  31 #include "mi-console.h"
  32 #include "mi-common.h"
  33 #include "observer.h"
  34 #include "gdbthread.h"
  35 #include "solist.h"
  36 #include "gdb.h"
  37 #include "objfiles.h"
  38 #include "tracepoint.h"
  39 #include "cli-out.h"
  40 #include "thread-fsm.h"
  41 #include "cli/cli-interp.h"
  42
  43 /* These are the interpreter setup, etc. functions for the MI
  44    interpreter.  */
  45
  46 static void mi_execute_command_wrapper (const char *cmd);
  47 static void mi_execute_command_input_handler (char *cmd);
  48
  49 /* These are hooks that we put in place while doing interpreter_exec
  50    so we can report interesting things that happened "behind the MI's
  51    back" in this command.  */
  52
  53 static int mi_interp_query_hook (const char *ctlstr, va_list ap)
  54   ATTRIBUTE_PRINTF (1, 0);
  55
  56 static void mi_insert_notify_hooks (void);
  57 static void mi_remove_notify_hooks (void);
  58
  59 static void mi_on_signal_received (enum gdb_signal siggnal);
  60 static void mi_on_end_stepping_range (void);
  61 static void mi_on_signal_exited (enum gdb_signal siggnal);
  62 static void mi_on_exited (int exitstatus);
  63 static void mi_on_normal_stop (struct bpstats *bs, int print_frame);
  64 static void mi_on_no_history (void);
  65
  66 static void mi_new_thread (struct thread_info *t);
  67 static void mi_thread_exit (struct thread_info *t, int silent);
  68 static void mi_record_changed (struct inferior*, int, const char *,
  69                                const char *);
  70 static void mi_inferior_added (struct inferior *inf);
  71 static void mi_inferior_appeared (struct inferior *inf);
  72 static void mi_inferior_exit (struct inferior *inf);
  73 static void mi_inferior_removed (struct inferior *inf);
  74 static void mi_on_resume (ptid_t ptid);
  75 static void mi_solib_loaded (struct so_list *solib);
  76 static void mi_solib_unloaded (struct so_list *solib);
  77 static void mi_about_to_proceed (void);
  78 static void mi_traceframe_changed (int tfnum, int tpnum);
  79 static void mi_tsv_created (const struct trace_state_variable *tsv);
  80 static void mi_tsv_deleted (const struct trace_state_variable *tsv);
  81 static void mi_tsv_modified (const struct trace_state_variable *tsv);
  82 static void mi_breakpoint_created (struct breakpoint *b);
  83 static void mi_breakpoint_deleted (struct breakpoint *b);
  84 static void mi_breakpoint_modified (struct breakpoint *b);
  85 static void mi_command_param_changed (const char *param, const char *value);
  86 static void mi_memory_changed (struct inferior *inf, CORE_ADDR memaddr,
  87                                ssize_t len, const bfd_byte *myaddr);
  88 static void mi_on_sync_execution_done (void);
  89
  90 static int report_initial_inferior (struct inferior *inf, void *closure);
  91
  92 /* Display the MI prompt.  */
  93
  94 static void
  95 display_mi_prompt (struct mi_interp *mi)
  96 {
  97   struct ui *ui = current_ui;
  98
  99   fputs_unfiltered ("(gdb) \n", mi->raw_stdout);
 100   gdb_flush (mi->raw_stdout);
 101   ui->prompt_state = PROMPTED;
 102 }
 103
 104 /* Returns the INTERP's data cast as mi_interp if INTERP is an MI, and
 105    returns NULL otherwise.  */
 106
 107 static struct mi_interp *
 108 as_mi_interp (struct interp *interp)
 109 {
 110   if (interp_ui_out (interp)->is_mi_like_p ())
 111     return (struct mi_interp *) interp;
 112   return NULL;
 113 }
 114
 115 void
 116 mi_interp::init (bool top_level)
 117 {
 118   mi_interp *mi = this;
 119   const char *name;
 120   int mi_version;
 121
 122   /* Store the current output channel, so that we can create a console
 123      channel that encapsulates and prefixes all gdb_output-type bits
 124      coming from the rest of the debugger.  */
 125   mi->raw_stdout = gdb_stdout;
 126
 127   /* Create MI console channels, each with a different prefix so they
 128      can be distinguished.  */
 129   mi->out = new mi_console_file (mi->raw_stdout, "~", '"');
 130   mi->err = new mi_console_file (mi->raw_stdout, "&", '"');
 131   mi->log = mi->err;
 132   mi->targ = new mi_console_file (mi->raw_stdout, "@", '"');
 133   mi->event_channel = new mi_console_file (mi->raw_stdout, "=", 0);
 134
 135   name = interp_name (this);
 136   /* INTERP_MI selects the most recent released version.  "mi2" was
 137      released as part of GDB 6.0.  */
 138   if (strcmp (name, INTERP_MI) == 0)
 139     mi_version = 2;
 140   else if (strcmp (name, INTERP_MI1) == 0)
 141     mi_version = 1;
 142   else if (strcmp (name, INTERP_MI2) == 0)
 143     mi_version = 2;
 144   else if (strcmp (name, INTERP_MI3) == 0)
 145     mi_version = 3;
 146   else
 147     gdb_assert_not_reached ("unhandled MI version");
 148
 149   mi->mi_uiout = mi_out_new (mi_version);
 150   mi->cli_uiout = cli_out_new (mi->out);
 151
 152   if (top_level)
 153     {
 154       /* The initial inferior is created before this function is
 155          called, so we need to report it explicitly.  Use iteration in
 156          case future version of GDB creates more than one inferior
 157          up-front.  */
 158       iterate_over_inferiors (report_initial_inferior, mi);
 159     }
 160 }
 161
 162 void
 163 mi_interp::resume ()
 164 {
 165   struct mi_interp *mi = this;
 166   struct ui *ui = current_ui;
 167
 168   /* As per hack note in mi_interpreter_init, swap in the output
 169      channels... */
 170   gdb_setup_readline (0);
 171
 172   ui->call_readline = gdb_readline_no_editing_callback;
 173   ui->input_handler = mi_execute_command_input_handler;
 174
 175   gdb_stdout = mi->out;
 176   /* Route error and log output through the MI.  */
 177   gdb_stderr = mi->err;
 178   gdb_stdlog = mi->log;
 179   /* Route target output through the MI.  */
 180   gdb_stdtarg = mi->targ;
 181   /* Route target error through the MI as well.  */
 182   gdb_stdtargerr = mi->targ;
 183
 184   /* Replace all the hooks that we know about.  There really needs to
 185      be a better way of doing this... */
 186   clear_interpreter_hooks ();
 187
 188   deprecated_show_load_progress = mi_load_progress;
 189 }
 190
 191 void
 192 mi_interp::suspend ()
 193 {
 194   gdb_disable_readline ();
 195 }
 196
 197 gdb_exception
 198 mi_interp::exec (const char *command)
 199 {
 200   mi_execute_command_wrapper (command);
 201   return exception_none;
 202 }
 203
 204 void
 205 mi_cmd_interpreter_exec (const char *command, char **argv, int argc)
 206 {
 207   struct interp *interp_to_use;
 208   int i;
 209   char *mi_error_message = NULL;
 210   struct cleanup *old_chain;
 211
 212   if (argc < 2)
 213     error (_("-interpreter-exec: "
 214              "Usage: -interpreter-exec interp command"));
 215
 216   interp_to_use = interp_lookup (current_ui, argv[0]);
 217   if (interp_to_use == NULL)
 218     error (_("-interpreter-exec: could not find interpreter \"%s\""),
 219            argv[0]);
 220
 221   /* Note that unlike the CLI version of this command, we don't
 222      actually set INTERP_TO_USE as the current interpreter, as we
 223      still want gdb_stdout, etc. to point at MI streams.  */
 224
 225   /* Insert the MI out hooks, making sure to also call the
 226      interpreter's hooks if it has any.  */
 227   /* KRS: We shouldn't need this... Events should be installed and
 228      they should just ALWAYS fire something out down the MI
 229      channel.  */
 230   mi_insert_notify_hooks ();
 231
 232   /* Now run the code.  */
 233
 234   old_chain = make_cleanup (null_cleanup, 0);
 235   for (i = 1; i < argc; i++)
 236     {
 237       struct gdb_exception e = interp_exec (interp_to_use, argv[i]);
 238
 239       if (e.reason < 0)
 240         {
 241           mi_error_message = xstrdup (e.message);
 242           make_cleanup (xfree, mi_error_message);
 243           break;
 244         }
 245     }
 246
 247   mi_remove_notify_hooks ();
 248
 249   if (mi_error_message != NULL)
 250     error ("%s", mi_error_message);
 251   do_cleanups (old_chain);
 252 }
 253
 254 /* This inserts a number of hooks that are meant to produce
 255    async-notify ("=") MI messages while running commands in another
 256    interpreter using mi_interpreter_exec.  The canonical use for this
 257    is to allow access to the gdb CLI interpreter from within the MI,
 258    while still producing MI style output when actions in the CLI
 259    command change GDB's state.  */
 260
 261 static void
 262 mi_insert_notify_hooks (void)
 263 {
 264   deprecated_query_hook = mi_interp_query_hook;
 265 }
 266
 267 static void
 268 mi_remove_notify_hooks (void)
 269 {
 270   deprecated_query_hook = NULL;
 271 }
 272
 273 static int
 274 mi_interp_query_hook (const char *ctlstr, va_list ap)
 275 {
 276   return 1;
 277 }
 278
 279 static void
 280 mi_execute_command_wrapper (const char *cmd)
 281 {
 282   struct ui *ui = current_ui;
 283
 284   mi_execute_command (cmd, ui->instream == ui->stdin_stream);
 285 }
 286
 287 /* Observer for the synchronous_command_done notification.  */
 288
 289 static void
 290 mi_on_sync_execution_done (void)
 291 {
 292   struct ui *ui = current_ui;
 293   struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
 294
 295   if (mi == NULL)
 296     return;
 297
 298   /* If MI is sync, then output the MI prompt now, indicating we're
 299      ready for further input.  */
 300   if (!mi_async_p ())
 301     display_mi_prompt (mi);
 302 }
 303
 304 /* mi_execute_command_wrapper wrapper suitable for INPUT_HANDLER.  */
 305
 306 static void
 307 mi_execute_command_input_handler (char *cmd)
 308 {
 309   struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
 310   struct ui *ui = current_ui;
 311
 312   ui->prompt_state = PROMPT_NEEDED;
 313
 314   mi_execute_command_wrapper (cmd);
 315
 316   /* Print a prompt, indicating we're ready for further input, unless
 317      we just started a synchronous command.  In that case, we're about
 318      to go back to the event loop and will output the prompt in the
 319      'synchronous_command_done' observer when the target next
 320      stops.  */
 321   if (ui->prompt_state == PROMPT_NEEDED)
 322     display_mi_prompt (mi);
 323 }
 324
 325 void
 326 mi_interp::pre_command_loop ()
 327 {
 328   struct mi_interp *mi = this;
 329
 330   /* Turn off 8 bit strings in quoted output.  Any character with the
 331      high bit set is printed using C's octal format.  */
 332   sevenbit_strings = 1;
 333
 334   /* Tell the world that we're alive.  */
 335   display_mi_prompt (mi);
 336 }
 337
 338 static void
 339 mi_new_thread (struct thread_info *t)
 340 {
 341   struct inferior *inf = find_inferior_ptid (t->ptid);
 342
 343   gdb_assert (inf);
 344
 345   SWITCH_THRU_ALL_UIS ()
 346     {
 347       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
 348       struct cleanup *old_chain;
 349
 350       if (mi == NULL)
 351         continue;
 352
 353       old_chain = make_cleanup_restore_target_terminal ();
 354       target_terminal_ours_for_output ();
 355
 356       fprintf_unfiltered (mi->event_channel,
 357                           "thread-created,id=\"%d\",group-id=\"i%d\"",
 358                           t->global_num, inf->num);
 359       gdb_flush (mi->event_channel);
 360
 361       do_cleanups (old_chain);
 362     }
 363 }
 364
 365 static void
 366 mi_thread_exit (struct thread_info *t, int silent)
 367 {
 368   if (silent)
 369     return;
 370
 371   SWITCH_THRU_ALL_UIS ()
 372     {
 373       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
 374       struct cleanup *old_chain;
 375
 376       if (mi == NULL)
 377         continue;
 378
 379       old_chain = make_cleanup_restore_target_terminal ();
 380       target_terminal_ours_for_output ();
 381       fprintf_unfiltered (mi->event_channel,
 382                           "thread-exited,id=\"%d\",group-id=\"i%d\"",
 383                           t->global_num, t->inf->num);
 384       gdb_flush (mi->event_channel);
 385
 386       do_cleanups (old_chain);
 387     }
 388 }
 389
 390 /* Emit notification on changing the state of record.  */
 391
 392 static void
 393 mi_record_changed (struct inferior *inferior, int started, const char *method,
 394                    const char *format)
 395 {
 396   SWITCH_THRU_ALL_UIS ()
 397     {
 398       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
 399       struct cleanup *old_chain;
 400
 401       if (mi == NULL)
 402         continue;
 403
 404       old_chain = make_cleanup_restore_target_terminal ();
 405       target_terminal_ours_for_output ();
 406
 407       if (started)
 408         {
 409           if (format != NULL)
 410             {
 411               fprintf_unfiltered (mi->event_channel,
 412                                   "record-started,thread-group=\"i%d\","
 413                                   "method=\"%s\",format=\"%s\"",
 414                                   inferior->num, method, format);
 415             }
 416           else
 417             {
 418               fprintf_unfiltered (mi->event_channel,
 419                                   "record-started,thread-group=\"i%d\","
 420                                   "method=\"%s\"",
 421                                   inferior->num, method);
 422             }
 423         }
 424       else
 425         {
 426           fprintf_unfiltered (mi->event_channel,
 427                               "record-stopped,thread-group=\"i%d\"",
 428                               inferior->num);
 429         }
 430
 431       gdb_flush (mi->event_channel);
 432
 433       do_cleanups (old_chain);
 434     }
 435 }
 436
 437 static void
 438 mi_inferior_added (struct inferior *inf)
 439 {
 440   SWITCH_THRU_ALL_UIS ()
 441     {
 442       struct interp *interp;
 443       struct mi_interp *mi;
 444       struct cleanup *old_chain;
 445
 446       /* We'll be called once for the initial inferior, before the top
 447          level interpreter is set.  */
 448       interp = top_level_interpreter ();
 449       if (interp == NULL)
 450         continue;
 451
 452       mi = as_mi_interp (interp);
 453       if (mi == NULL)
 454         continue;
 455
 456       old_chain = make_cleanup_restore_target_terminal ();
 457       target_terminal_ours_for_output ();
 458
 459       fprintf_unfiltered (mi->event_channel,
 460                           "thread-group-added,id=\"i%d\"",
 461                           inf->num);
 462       gdb_flush (mi->event_channel);
 463
 464       do_cleanups (old_chain);
 465     }
 466 }
 467
 468 static void
 469 mi_inferior_appeared (struct inferior *inf)
 470 {
 471   SWITCH_THRU_ALL_UIS ()
 472     {
 473       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
 474       struct cleanup *old_chain;
 475
 476       if (mi == NULL)
 477         continue;
 478
 479       old_chain = make_cleanup_restore_target_terminal ();
 480       target_terminal_ours_for_output ();
 481
 482       fprintf_unfiltered (mi->event_channel,
 483                           "thread-group-started,id=\"i%d\",pid=\"%d\"",
 484                           inf->num, inf->pid);
 485       gdb_flush (mi->event_channel);
 486       do_cleanups (old_chain);
 487     }
 488 }
 489
 490 static void
 491 mi_inferior_exit (struct inferior *inf)
 492 {
 493   SWITCH_THRU_ALL_UIS ()
 494     {
 495       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
 496       struct cleanup *old_chain;
 497
 498       if (mi == NULL)
 499         continue;
 500
 501       old_chain = make_cleanup_restore_target_terminal ();
 502       target_terminal_ours_for_output ();
 503
 504       if (inf->has_exit_code)
 505         fprintf_unfiltered (mi->event_channel,
 506                             "thread-group-exited,id=\"i%d\",exit-code=\"%s\"",
 507                             inf->num, int_string (inf->exit_code, 8, 0, 0, 1));
 508       else
 509         fprintf_unfiltered (mi->event_channel,
 510                             "thread-group-exited,id=\"i%d\"", inf->num);
 511
 512       gdb_flush (mi->event_channel);
 513       do_cleanups (old_chain);
 514     }
 515 }
 516
 517 static void
 518 mi_inferior_removed (struct inferior *inf)
 519 {
 520   SWITCH_THRU_ALL_UIS ()
 521     {
 522       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
 523       struct cleanup *old_chain;
 524
 525       if (mi == NULL)
 526         continue;
 527
 528       old_chain = make_cleanup_restore_target_terminal ();
 529       target_terminal_ours_for_output ();
 530
 531       fprintf_unfiltered (mi->event_channel,
 532                           "thread-group-removed,id=\"i%d\"",
 533                           inf->num);
 534       gdb_flush (mi->event_channel);
 535
 536       do_cleanups (old_chain);
 537     }
 538 }
 539
 540 /* Return the MI interpreter, if it is active -- either because it's
 541    the top-level interpreter or the interpreter executing the current
 542    command.  Returns NULL if the MI interpreter is not being used.  */
 543
 544 static struct mi_interp *
 545 find_mi_interp (void)
 546 {
 547   struct mi_interp *mi;
 548
 549   mi = as_mi_interp (top_level_interpreter ());
 550   if (mi != NULL)
 551     return mi;
 552
 553   mi = as_mi_interp (command_interp ());
 554   if (mi != NULL)
 555     return mi;
 556
 557   return NULL;
 558 }
 559
 560 /* Observers for several run control events that print why the
 561    inferior has stopped to both the the MI event channel and to the MI
 562    console.  If the MI interpreter is not active, print nothing.  */
 563
 564 /* Observer for the signal_received notification.  */
 565
 566 static void
 567 mi_on_signal_received (enum gdb_signal siggnal)
 568 {
 569   SWITCH_THRU_ALL_UIS ()
 570     {
 571       struct mi_interp *mi = find_mi_interp ();
 572
 573       if (mi == NULL)
 574         continue;
 575
 576       print_signal_received_reason (mi->mi_uiout, siggnal);
 577       print_signal_received_reason (mi->cli_uiout, siggnal);
 578     }
 579 }
 580
 581 /* Observer for the end_stepping_range notification.  */
 582
 583 static void
 584 mi_on_end_stepping_range (void)
 585 {
 586   SWITCH_THRU_ALL_UIS ()
 587     {
 588       struct mi_interp *mi = find_mi_interp ();
 589
 590       if (mi == NULL)
 591         continue;
 592
 593       print_end_stepping_range_reason (mi->mi_uiout);
 594       print_end_stepping_range_reason (mi->cli_uiout);
 595     }
 596 }
 597
 598 /* Observer for the signal_exited notification.  */
 599
 600 static void
 601 mi_on_signal_exited (enum gdb_signal siggnal)
 602 {
 603   SWITCH_THRU_ALL_UIS ()
 604     {
 605       struct mi_interp *mi = find_mi_interp ();
 606
 607       if (mi == NULL)
 608         continue;
 609
 610       print_signal_exited_reason (mi->mi_uiout, siggnal);
 611       print_signal_exited_reason (mi->cli_uiout, siggnal);
 612     }
 613 }
 614
 615 /* Observer for the exited notification.  */
 616
 617 static void
 618 mi_on_exited (int exitstatus)
 619 {
 620   SWITCH_THRU_ALL_UIS ()
 621     {
 622       struct mi_interp *mi = find_mi_interp ();
 623
 624       if (mi == NULL)
 625         continue;
 626
 627       print_exited_reason (mi->mi_uiout, exitstatus);
 628       print_exited_reason (mi->cli_uiout, exitstatus);
 629     }
 630 }
 631
 632 /* Observer for the no_history notification.  */
 633
 634 static void
 635 mi_on_no_history (void)
 636 {
 637   SWITCH_THRU_ALL_UIS ()
 638     {
 639       struct mi_interp *mi = find_mi_interp ();
 640
 641       if (mi == NULL)
 642         continue;
 643
 644       print_no_history_reason (mi->mi_uiout);
 645       print_no_history_reason (mi->cli_uiout);
 646     }
 647 }
 648
 649 static void
 650 mi_on_normal_stop_1 (struct bpstats *bs, int print_frame)
 651 {
 652   /* Since this can be called when CLI command is executing,
 653      using cli interpreter, be sure to use MI uiout for output,
 654      not the current one.  */
 655   struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
 656   struct mi_interp *mi = (struct mi_interp *) top_level_interpreter ();
 657
 658   if (print_frame)
 659     {
 660       struct thread_info *tp;
 661       int core;
 662       struct interp *console_interp;
 663
 664       tp = inferior_thread ();
 665
 666       if (tp->thread_fsm != NULL
 667           && thread_fsm_finished_p (tp->thread_fsm))
 668         {
 669           enum async_reply_reason reason;
 670
 671           reason = thread_fsm_async_reply_reason (tp->thread_fsm);
 672           mi_uiout->field_string ("reason", async_reason_lookup (reason));
 673         }
 674       print_stop_event (mi_uiout);
 675
 676       console_interp = interp_lookup (current_ui, INTERP_CONSOLE);
 677       if (should_print_stop_to_console (console_interp, tp))
 678         print_stop_event (mi->cli_uiout);
 679
 680       mi_uiout->field_int ("thread-id", tp->global_num);
 681       if (non_stop)
 682         {
 683           struct cleanup *back_to = make_cleanup_ui_out_list_begin_end
 684             (mi_uiout, "stopped-threads");
 685
 686           mi_uiout->field_int (NULL, tp->global_num);
 687           do_cleanups (back_to);
 688         }
 689       else
 690         mi_uiout->field_string ("stopped-threads", "all");
 691
 692       core = target_core_of_thread (inferior_ptid);
 693       if (core != -1)
 694         mi_uiout->field_int ("core", core);
 695     }
 696
 697   fputs_unfiltered ("*stopped", mi->raw_stdout);
 698   mi_out_put (mi_uiout, mi->raw_stdout);
 699   mi_out_rewind (mi_uiout);
 700   mi_print_timing_maybe (mi->raw_stdout);
 701   fputs_unfiltered ("\n", mi->raw_stdout);
 702   gdb_flush (mi->raw_stdout);
 703 }
 704
 705 static void
 706 mi_on_normal_stop (struct bpstats *bs, int print_frame)
 707 {
 708   SWITCH_THRU_ALL_UIS ()
 709     {
 710       if (as_mi_interp (top_level_interpreter ()) == NULL)
 711         continue;
 712
 713       mi_on_normal_stop_1 (bs, print_frame);
 714     }
 715 }
 716
 717 static void
 718 mi_about_to_proceed (void)
 719 {
 720   /* Suppress output while calling an inferior function.  */
 721
 722   if (!ptid_equal (inferior_ptid, null_ptid))
 723     {
 724       struct thread_info *tp = inferior_thread ();
 725
 726       if (tp->control.in_infcall)
 727         return;
 728     }
 729
 730   mi_proceeded = 1;
 731 }
 732
 733 /* When the element is non-zero, no MI notifications will be emitted in
 734    response to the corresponding observers.  */
 735
 736 struct mi_suppress_notification mi_suppress_notification =
 737   {
 738     0,
 739     0,
 740     0,
 741     0,
 742   };
 743
 744 /* Emit notification on changing a traceframe.  */
 745
 746 static void
 747 mi_traceframe_changed (int tfnum, int tpnum)
 748 {
 749   if (mi_suppress_notification.traceframe)
 750     return;
 751
 752   SWITCH_THRU_ALL_UIS ()
 753     {
 754       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
 755       struct cleanup *old_chain;
 756
 757       if (mi == NULL)
 758         continue;
 759
 760       old_chain = make_cleanup_restore_target_terminal ();
 761       target_terminal_ours_for_output ();
 762
 763       if (tfnum >= 0)
 764         fprintf_unfiltered (mi->event_channel, "traceframe-changed,"
 765                             "num=\"%d\",tracepoint=\"%d\"\n",
 766                             tfnum, tpnum);
 767       else
 768         fprintf_unfiltered (mi->event_channel, "traceframe-changed,end");
 769
 770       gdb_flush (mi->event_channel);
 771
 772       do_cleanups (old_chain);
 773     }
 774 }
 775
 776 /* Emit notification on creating a trace state variable.  */
 777
 778 static void
 779 mi_tsv_created (const struct trace_state_variable *tsv)
 780 {
 781   SWITCH_THRU_ALL_UIS ()
 782     {
 783       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
 784       struct cleanup *old_chain;
 785
 786       if (mi == NULL)
 787         continue;
 788
 789       old_chain = make_cleanup_restore_target_terminal ();
 790       target_terminal_ours_for_output ();
 791
 792       fprintf_unfiltered (mi->event_channel, "tsv-created,"
 793                           "name=\"%s\",initial=\"%s\"\n",
 794                           tsv->name, plongest (tsv->initial_value));
 795
 796       gdb_flush (mi->event_channel);
 797
 798       do_cleanups (old_chain);
 799     }
 800 }
 801
 802 /* Emit notification on deleting a trace state variable.  */
 803
 804 static void
 805 mi_tsv_deleted (const struct trace_state_variable *tsv)
 806 {
 807   SWITCH_THRU_ALL_UIS ()
 808     {
 809       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
 810       struct cleanup *old_chain;
 811
 812       if (mi == NULL)
 813         continue;
 814
 815       old_chain = make_cleanup_restore_target_terminal ();
 816       target_terminal_ours_for_output ();
 817
 818       if (tsv != NULL)
 819         fprintf_unfiltered (mi->event_channel, "tsv-deleted,"
 820                             "name=\"%s\"\n", tsv->name);
 821       else
 822         fprintf_unfiltered (mi->event_channel, "tsv-deleted\n");
 823
 824       gdb_flush (mi->event_channel);
 825
 826       do_cleanups (old_chain);
 827     }
 828 }
 829
 830 /* Emit notification on modifying a trace state variable.  */
 831
 832 static void
 833 mi_tsv_modified (const struct trace_state_variable *tsv)
 834 {
 835   SWITCH_THRU_ALL_UIS ()
 836     {
 837       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
 838       struct ui_out *mi_uiout;
 839       struct cleanup *old_chain;
 840
 841       if (mi == NULL)
 842         continue;
 843
 844       mi_uiout = interp_ui_out (top_level_interpreter ());
 845
 846       old_chain = make_cleanup_restore_target_terminal ();
 847       target_terminal_ours_for_output ();
 848
 849       fprintf_unfiltered (mi->event_channel,
 850                           "tsv-modified");
 851
 852       mi_uiout->redirect (mi->event_channel);
 853
 854       mi_uiout->field_string ("name", tsv->name);
 855       mi_uiout->field_string ("initial",
 856                            plongest (tsv->initial_value));
 857       if (tsv->value_known)
 858         mi_uiout->field_string ("current", plongest (tsv->value));
 859
 860       mi_uiout->redirect (NULL);
 861
 862       gdb_flush (mi->event_channel);
 863
 864       do_cleanups (old_chain);
 865     }
 866 }
 867
 868 /* Emit notification about a created breakpoint.  */
 869
 870 static void
 871 mi_breakpoint_created (struct breakpoint *b)
 872 {
 873   if (mi_suppress_notification.breakpoint)
 874     return;
 875
 876   if (b->number <= 0)
 877     return;
 878
 879   SWITCH_THRU_ALL_UIS ()
 880     {
 881       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
 882       struct ui_out *mi_uiout;
 883       struct cleanup *old_chain;
 884
 885       if (mi == NULL)
 886         continue;
 887
 888       mi_uiout = interp_ui_out (top_level_interpreter ());
 889
 890       old_chain = make_cleanup_restore_target_terminal ();
 891       target_terminal_ours_for_output ();
 892
 893       fprintf_unfiltered (mi->event_channel,
 894                           "breakpoint-created");
 895       /* We want the output from gdb_breakpoint_query to go to
 896          mi->event_channel.  One approach would be to just call
 897          gdb_breakpoint_query, and then use mi_out_put to send the current
 898          content of mi_uiout into mi->event_channel.  However, that will
 899          break if anything is output to mi_uiout prior to calling the
 900          breakpoint_created notifications.  So, we use
 901          ui_out_redirect.  */
 902       mi_uiout->redirect (mi->event_channel);
 903       TRY
 904         {
 905           gdb_breakpoint_query (mi_uiout, b->number, NULL);
 906         }
 907       CATCH (e, RETURN_MASK_ERROR)
 908         {
 909         }
 910       END_CATCH
 911
 912       mi_uiout->redirect (NULL);
 913
 914       gdb_flush (mi->event_channel);
 915
 916       do_cleanups (old_chain);
 917     }
 918 }
 919
 920 /* Emit notification about deleted breakpoint.  */
 921
 922 static void
 923 mi_breakpoint_deleted (struct breakpoint *b)
 924 {
 925   if (mi_suppress_notification.breakpoint)
 926     return;
 927
 928   if (b->number <= 0)
 929     return;
 930
 931   SWITCH_THRU_ALL_UIS ()
 932     {
 933       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
 934       struct cleanup *old_chain;
 935
 936       if (mi == NULL)
 937         continue;
 938
 939       old_chain = make_cleanup_restore_target_terminal ();
 940       target_terminal_ours_for_output ();
 941
 942       fprintf_unfiltered (mi->event_channel, "breakpoint-deleted,id=\"%d\"",
 943                           b->number);
 944
 945       gdb_flush (mi->event_channel);
 946
 947       do_cleanups (old_chain);
 948     }
 949 }
 950
 951 /* Emit notification about modified breakpoint.  */
 952
 953 static void
 954 mi_breakpoint_modified (struct breakpoint *b)
 955 {
 956   if (mi_suppress_notification.breakpoint)
 957     return;
 958
 959   if (b->number <= 0)
 960     return;
 961
 962   SWITCH_THRU_ALL_UIS ()
 963     {
 964       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
 965       struct cleanup *old_chain;
 966
 967       if (mi == NULL)
 968         continue;
 969
 970       old_chain = make_cleanup_restore_target_terminal ();
 971       target_terminal_ours_for_output ();
 972       fprintf_unfiltered (mi->event_channel,
 973                           "breakpoint-modified");
 974       /* We want the output from gdb_breakpoint_query to go to
 975          mi->event_channel.  One approach would be to just call
 976          gdb_breakpoint_query, and then use mi_out_put to send the current
 977          content of mi_uiout into mi->event_channel.  However, that will
 978          break if anything is output to mi_uiout prior to calling the
 979          breakpoint_created notifications.  So, we use
 980          ui_out_redirect.  */
 981       mi->mi_uiout->redirect (mi->event_channel);
 982       TRY
 983         {
 984           gdb_breakpoint_query (mi->mi_uiout, b->number, NULL);
 985         }
 986       CATCH (e, RETURN_MASK_ERROR)
 987         {
 988         }
 989       END_CATCH
 990
 991       mi->mi_uiout->redirect (NULL);
 992
 993       gdb_flush (mi->event_channel);
 994
 995       do_cleanups (old_chain);
 996     }
 997 }
 998
 999 static int
1000 mi_output_running_pid (struct thread_info *info, void *arg)
1001 {
1002   ptid_t *ptid = (ptid_t *) arg;
1003
1004   SWITCH_THRU_ALL_UIS ()
1005     {
1006       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
1007
1008       if (mi == NULL)
1009         continue;
1010
1011       if (ptid_get_pid (*ptid) == ptid_get_pid (info->ptid))
1012         fprintf_unfiltered (mi->raw_stdout,
1013                             "*running,thread-id=\"%d\"\n",
1014                             info->global_num);
1015     }
1016
1017   return 0;
1018 }
1019
1020 static int
1021 mi_inferior_count (struct inferior *inf, void *arg)
1022 {
1023   if (inf->pid != 0)
1024     {
1025       int *count_p = (int *) arg;
1026       (*count_p)++;
1027     }
1028
1029   return 0;
1030 }
1031
1032 static void
1033 mi_on_resume_1 (struct mi_interp *mi, ptid_t ptid)
1034 {
1035   /* To cater for older frontends, emit ^running, but do it only once
1036      per each command.  We do it here, since at this point we know
1037      that the target was successfully resumed, and in non-async mode,
1038      we won't return back to MI interpreter code until the target
1039      is done running, so delaying the output of "^running" until then
1040      will make it impossible for frontend to know what's going on.
1041
1042      In future (MI3), we'll be outputting "^done" here.  */
1043   if (!running_result_record_printed && mi_proceeded)
1044     {
1045       fprintf_unfiltered (mi->raw_stdout, "%s^running\n",
1046                           current_token ? current_token : "");
1047     }
1048
1049   if (ptid_get_pid (ptid) == -1)
1050     fprintf_unfiltered (mi->raw_stdout, "*running,thread-id=\"all\"\n");
1051   else if (ptid_is_pid (ptid))
1052     {
1053       int count = 0;
1054
1055       /* Backwards compatibility.  If there's only one inferior,
1056          output "all", otherwise, output each resumed thread
1057          individually.  */
1058       iterate_over_inferiors (mi_inferior_count, &count);
1059
1060       if (count == 1)
1061         fprintf_unfiltered (mi->raw_stdout, "*running,thread-id=\"all\"\n");
1062       else
1063         iterate_over_threads (mi_output_running_pid, &ptid);
1064     }
1065   else
1066     {
1067       struct thread_info *ti = find_thread_ptid (ptid);
1068
1069       gdb_assert (ti);
1070       fprintf_unfiltered (mi->raw_stdout, "*running,thread-id=\"%d\"\n",
1071                           ti->global_num);
1072     }
1073
1074   if (!running_result_record_printed && mi_proceeded)
1075     {
1076       running_result_record_printed = 1;
1077       /* This is what gdb used to do historically -- printing prompt
1078          even if it cannot actually accept any input.  This will be
1079          surely removed for MI3, and may be removed even earlier.  */
1080       if (current_ui->prompt_state == PROMPT_BLOCKED)
1081         fputs_unfiltered ("(gdb) \n", mi->raw_stdout);
1082     }
1083   gdb_flush (mi->raw_stdout);
1084 }
1085
1086 static void
1087 mi_on_resume (ptid_t ptid)
1088 {
1089   struct thread_info *tp = NULL;
1090
1091   if (ptid_equal (ptid, minus_one_ptid) || ptid_is_pid (ptid))
1092     tp = inferior_thread ();
1093   else
1094     tp = find_thread_ptid (ptid);
1095
1096   /* Suppress output while calling an inferior function.  */
1097   if (tp->control.in_infcall)
1098     return;
1099
1100   SWITCH_THRU_ALL_UIS ()
1101     {
1102       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
1103       struct cleanup *old_chain;
1104
1105       if (mi == NULL)
1106         continue;
1107
1108       old_chain = make_cleanup_restore_target_terminal ();
1109       target_terminal_ours_for_output ();
1110
1111       mi_on_resume_1 (mi, ptid);
1112
1113       do_cleanups (old_chain);
1114     }
1115 }
1116
1117 /* See mi-interp.h.  */
1118
1119 void
1120 mi_output_solib_attribs (ui_out *uiout, struct so_list *solib)
1121 {
1122   struct gdbarch *gdbarch = target_gdbarch ();
1123
1124   uiout->field_string ("id", solib->so_original_name);
1125   uiout->field_string ("target-name", solib->so_original_name);
1126   uiout->field_string ("host-name", solib->so_name);
1127   uiout->field_int ("symbols-loaded", solib->symbols_loaded);
1128   if (!gdbarch_has_global_solist (target_gdbarch ()))
1129       uiout->field_fmt ("thread-group", "i%d", current_inferior ()->num);
1130
1131   struct cleanup *cleanup
1132     = make_cleanup_ui_out_list_begin_end (uiout, "ranges");
1133   struct cleanup *tuple_clean_up
1134     = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1135   if (solib->addr_high != 0)
1136     {
1137       uiout->field_core_addr ("from", gdbarch, solib->addr_low);
1138       uiout->field_core_addr ("to", gdbarch, solib->addr_high);
1139     }
1140   do_cleanups (tuple_clean_up);
1141   do_cleanups (cleanup);
1142 }
1143
1144 static void
1145 mi_solib_loaded (struct so_list *solib)
1146 {
1147   SWITCH_THRU_ALL_UIS ()
1148     {
1149       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
1150       struct ui_out *uiout;
1151       struct cleanup *old_chain;
1152
1153       if (mi == NULL)
1154         continue;
1155
1156       uiout = interp_ui_out (top_level_interpreter ());
1157
1158       old_chain = make_cleanup_restore_target_terminal ();
1159       target_terminal_ours_for_output ();
1160
1161       fprintf_unfiltered (mi->event_channel, "library-loaded");
1162
1163       uiout->redirect (mi->event_channel);
1164
1165       mi_output_solib_attribs (uiout, solib);
1166
1167       uiout->redirect (NULL);
1168
1169       gdb_flush (mi->event_channel);
1170
1171       do_cleanups (old_chain);
1172     }
1173 }
1174
1175 static void
1176 mi_solib_unloaded (struct so_list *solib)
1177 {
1178   SWITCH_THRU_ALL_UIS ()
1179     {
1180       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
1181       struct ui_out *uiout;
1182       struct cleanup *old_chain;
1183
1184       if (mi == NULL)
1185         continue;
1186
1187       uiout = interp_ui_out (top_level_interpreter ());
1188
1189       old_chain = make_cleanup_restore_target_terminal ();
1190       target_terminal_ours_for_output ();
1191
1192       fprintf_unfiltered (mi->event_channel, "library-unloaded");
1193
1194       uiout->redirect (mi->event_channel);
1195
1196       uiout->field_string ("id", solib->so_original_name);
1197       uiout->field_string ("target-name", solib->so_original_name);
1198       uiout->field_string ("host-name", solib->so_name);
1199       if (!gdbarch_has_global_solist (target_gdbarch ()))
1200         {
1201           uiout->field_fmt ("thread-group", "i%d", current_inferior ()->num);
1202         }
1203
1204       uiout->redirect (NULL);
1205
1206       gdb_flush (mi->event_channel);
1207
1208       do_cleanups (old_chain);
1209     }
1210 }
1211
1212 /* Emit notification about the command parameter change.  */
1213
1214 static void
1215 mi_command_param_changed (const char *param, const char *value)
1216 {
1217   if (mi_suppress_notification.cmd_param_changed)
1218     return;
1219
1220   SWITCH_THRU_ALL_UIS ()
1221     {
1222       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
1223       struct ui_out *mi_uiout;
1224       struct cleanup *old_chain;
1225
1226       if (mi == NULL)
1227         continue;
1228
1229       mi_uiout = interp_ui_out (top_level_interpreter ());
1230
1231       old_chain = make_cleanup_restore_target_terminal ();
1232       target_terminal_ours_for_output ();
1233
1234       fprintf_unfiltered (mi->event_channel, "cmd-param-changed");
1235
1236       mi_uiout->redirect (mi->event_channel);
1237
1238       mi_uiout->field_string ("param", param);
1239       mi_uiout->field_string ("value", value);
1240
1241       mi_uiout->redirect (NULL);
1242
1243       gdb_flush (mi->event_channel);
1244
1245       do_cleanups (old_chain);
1246     }
1247 }
1248
1249 /* Emit notification about the target memory change.  */
1250
1251 static void
1252 mi_memory_changed (struct inferior *inferior, CORE_ADDR memaddr,
1253                    ssize_t len, const bfd_byte *myaddr)
1254 {
1255   if (mi_suppress_notification.memory)
1256     return;
1257
1258   SWITCH_THRU_ALL_UIS ()
1259     {
1260       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
1261       struct ui_out *mi_uiout;
1262       struct obj_section *sec;
1263       struct cleanup *old_chain;
1264
1265       if (mi == NULL)
1266         continue;
1267
1268       mi_uiout = interp_ui_out (top_level_interpreter ());
1269
1270       old_chain = make_cleanup_restore_target_terminal ();
1271       target_terminal_ours_for_output ();
1272
1273       fprintf_unfiltered (mi->event_channel, "memory-changed");
1274
1275       mi_uiout->redirect (mi->event_channel);
1276
1277       mi_uiout->field_fmt ("thread-group", "i%d", inferior->num);
1278       mi_uiout->field_core_addr ("addr", target_gdbarch (), memaddr);
1279       mi_uiout->field_fmt ("len", "%s", hex_string (len));
1280
1281       /* Append 'type=code' into notification if MEMADDR falls in the range of
1282          sections contain code.  */
1283       sec = find_pc_section (memaddr);
1284       if (sec != NULL && sec->objfile != NULL)
1285         {
1286           flagword flags = bfd_get_section_flags (sec->objfile->obfd,
1287                                                   sec->the_bfd_section);
1288
1289           if (flags & SEC_CODE)
1290             mi_uiout->field_string ("type", "code");
1291         }
1292
1293       mi_uiout->redirect (NULL);
1294
1295       gdb_flush (mi->event_channel);
1296
1297       do_cleanups (old_chain);
1298     }
1299 }
1300
1301 /* Emit an event when the selection context (inferior, thread, frame)
1302    changed.  */
1303
1304 static void
1305 mi_user_selected_context_changed (user_selected_what selection)
1306 {
1307   struct thread_info *tp;
1308
1309   /* Don't send an event if we're responding to an MI command.  */
1310   if (mi_suppress_notification.user_selected_context)
1311     return;
1312
1313   tp = find_thread_ptid (inferior_ptid);
1314
1315   SWITCH_THRU_ALL_UIS ()
1316     {
1317       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
1318       struct ui_out *mi_uiout;
1319       struct cleanup *old_chain;
1320
1321       if (mi == NULL)
1322         continue;
1323
1324       mi_uiout = interp_ui_out (top_level_interpreter ());
1325
1326       mi_uiout->redirect (mi->event_channel);
1327
1328       old_chain = make_cleanup_ui_out_redirect_pop (mi_uiout);
1329
1330       make_cleanup_restore_target_terminal ();
1331       target_terminal_ours_for_output ();
1332
1333       if (selection & USER_SELECTED_INFERIOR)
1334         print_selected_inferior (mi->cli_uiout);
1335
1336       if (tp != NULL
1337           && (selection & (USER_SELECTED_THREAD | USER_SELECTED_FRAME)))
1338         {
1339           print_selected_thread_frame (mi->cli_uiout, selection);
1340
1341           fprintf_unfiltered (mi->event_channel,
1342                               "thread-selected,id=\"%d\"",
1343                               tp->global_num);
1344
1345           if (tp->state != THREAD_RUNNING)
1346             {
1347               if (has_stack_frames ())
1348                 print_stack_frame_to_uiout (mi_uiout, get_selected_frame (NULL),
1349                                             1, SRC_AND_LOC, 1);
1350             }
1351         }
1352
1353       gdb_flush (mi->event_channel);
1354       do_cleanups (old_chain);
1355     }
1356 }
1357
1358 static int
1359 report_initial_inferior (struct inferior *inf, void *closure)
1360 {
1361   /* This function is called from mi_interpreter_init, and since
1362      mi_inferior_added assumes that inferior is fully initialized
1363      and top_level_interpreter_data is set, we cannot call
1364      it here.  */
1365   struct mi_interp *mi = (struct mi_interp *) closure;
1366   struct cleanup *old_chain;
1367
1368   old_chain = make_cleanup_restore_target_terminal ();
1369   target_terminal_ours_for_output ();
1370
1371   fprintf_unfiltered (mi->event_channel,
1372                       "thread-group-added,id=\"i%d\"",
1373                       inf->num);
1374   gdb_flush (mi->event_channel);
1375
1376   do_cleanups (old_chain);
1377   return 0;
1378 }
1379
1380 ui_out *
1381 mi_interp::interp_ui_out ()
1382 {
1383   return this->mi_uiout;
1384 }
1385
1386 /* Do MI-specific logging actions; save raw_stdout, and change all
1387    the consoles to use the supplied ui-file(s).  */
1388
1389 void
1390 mi_interp::set_logging (ui_file_up logfile, bool logging_redirect)
1391 {
1392   struct mi_interp *mi = this;
1393
1394   if (logfile != NULL)
1395     {
1396       mi->saved_raw_stdout = mi->raw_stdout;
1397       mi->raw_stdout = make_logging_output (mi->raw_stdout,
1398                                             std::move (logfile),
1399                                             logging_redirect);
1400
1401     }
1402   else
1403     {
1404       delete mi->raw_stdout;
1405       mi->raw_stdout = mi->saved_raw_stdout;
1406       mi->saved_raw_stdout = NULL;
1407     }
1408
1409   mi->out->set_raw (mi->raw_stdout);
1410   mi->err->set_raw (mi->raw_stdout);
1411   mi->log->set_raw (mi->raw_stdout);
1412   mi->targ->set_raw (mi->raw_stdout);
1413   mi->event_channel->set_raw (mi->raw_stdout);
1414 }
1415
1416 /* Factory for MI interpreters.  */
1417
1418 static struct interp *
1419 mi_interp_factory (const char *name)
1420 {
1421   return new mi_interp (name);
1422 }
1423
1424 extern initialize_file_ftype _initialize_mi_interp; /* -Wmissing-prototypes */
1425
1426 void
1427 _initialize_mi_interp (void)
1428 {
1429   /* The various interpreter levels.  */
1430   interp_factory_register (INTERP_MI1, mi_interp_factory);
1431   interp_factory_register (INTERP_MI2, mi_interp_factory);
1432   interp_factory_register (INTERP_MI3, mi_interp_factory);
1433   interp_factory_register (INTERP_MI, mi_interp_factory);
1434
1435   observer_attach_signal_received (mi_on_signal_received);
1436   observer_attach_end_stepping_range (mi_on_end_stepping_range);
1437   observer_attach_signal_exited (mi_on_signal_exited);
1438   observer_attach_exited (mi_on_exited);
1439   observer_attach_no_history (mi_on_no_history);
1440   observer_attach_new_thread (mi_new_thread);
1441   observer_attach_thread_exit (mi_thread_exit);
1442   observer_attach_inferior_added (mi_inferior_added);
1443   observer_attach_inferior_appeared (mi_inferior_appeared);
1444   observer_attach_inferior_exit (mi_inferior_exit);
1445   observer_attach_inferior_removed (mi_inferior_removed);
1446   observer_attach_record_changed (mi_record_changed);
1447   observer_attach_normal_stop (mi_on_normal_stop);
1448   observer_attach_target_resumed (mi_on_resume);
1449   observer_attach_solib_loaded (mi_solib_loaded);
1450   observer_attach_solib_unloaded (mi_solib_unloaded);
1451   observer_attach_about_to_proceed (mi_about_to_proceed);
1452   observer_attach_traceframe_changed (mi_traceframe_changed);
1453   observer_attach_tsv_created (mi_tsv_created);
1454   observer_attach_tsv_deleted (mi_tsv_deleted);
1455   observer_attach_tsv_modified (mi_tsv_modified);
1456   observer_attach_breakpoint_created (mi_breakpoint_created);
1457   observer_attach_breakpoint_deleted (mi_breakpoint_deleted);
1458   observer_attach_breakpoint_modified (mi_breakpoint_modified);
1459   observer_attach_command_param_changed (mi_command_param_changed);
1460   observer_attach_memory_changed (mi_memory_changed);
1461   observer_attach_sync_execution_done (mi_on_sync_execution_done);
1462   observer_attach_user_selected_context_changed
1463     (mi_user_selected_context_changed);
1464 }