gdb/mi/mi-interp.c

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