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
  42 /* These are the interpreter setup, etc. functions for the MI
  43    interpreter.  */
  44
  45 static void mi_execute_command_wrapper (const char *cmd);
  46 static void mi_execute_command_input_handler (char *cmd);
  47 static void mi_command_loop (void *data);
  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 /* Returns the INTERP's data cast as mi_interp if INTERP is an MI, and
  93    returns NULL otherwise.  */
  94
  95 static struct mi_interp *
  96 as_mi_interp (struct interp *interp)
  97 {
  98   if (ui_out_is_mi_like_p (interp_ui_out (interp)))
  99     return (struct mi_interp *) interp_data (interp);
 100   return NULL;
 101 }
 102
 103 static void *
 104 mi_interpreter_init (struct interp *interp, int top_level)
 105 {
 106   struct mi_interp *mi = XNEW (struct mi_interp);
 107   const char *name;
 108   int mi_version;
 109
 110   /* Assign the output channel created at startup to its own global,
 111      so that we can create a console channel that encapsulates and
 112      prefixes all gdb_output-type bits coming from the rest of the
 113      debugger.  */
 114
 115   raw_stdout = gdb_stdout;
 116
 117   /* Create MI console channels, each with a different prefix so they
 118      can be distinguished.  */
 119   mi->out = mi_console_file_new (raw_stdout, "~", '"');
 120   mi->err = mi_console_file_new (raw_stdout, "&", '"');
 121   mi->log = mi->err;
 122   mi->targ = mi_console_file_new (raw_stdout, "@", '"');
 123   mi->event_channel = mi_console_file_new (raw_stdout, "=", 0);
 124
 125   name = interp_name (interp);
 126   /* INTERP_MI selects the most recent released version.  "mi2" was
 127      released as part of GDB 6.0.  */
 128   if (strcmp (name, INTERP_MI) == 0)
 129     mi_version = 2;
 130   else if (strcmp (name, INTERP_MI1) == 0)
 131     mi_version = 1;
 132   else if (strcmp (name, INTERP_MI2) == 0)
 133     mi_version = 2;
 134   else if (strcmp (name, INTERP_MI3) == 0)
 135     mi_version = 3;
 136   else
 137     gdb_assert_not_reached ("unhandled MI version");
 138
 139   mi->mi_uiout = mi_out_new (mi_version);
 140   mi->cli_uiout = cli_out_new (mi->out);
 141
 142   if (top_level)
 143     {
 144       /* The initial inferior is created before this function is
 145          called, so we need to report it explicitly.  Use iteration in
 146          case future version of GDB creates more than one inferior
 147          up-front.  */
 148       iterate_over_inferiors (report_initial_inferior, mi);
 149     }
 150
 151   return mi;
 152 }
 153
 154 static int
 155 mi_interpreter_resume (void *data)
 156 {
 157   struct mi_interp *mi = (struct mi_interp *) data;
 158   struct ui *ui = current_ui;
 159
 160   /* As per hack note in mi_interpreter_init, swap in the output
 161      channels... */
 162   gdb_setup_readline ();
 163
 164   /* These overwrite some of the initialization done in
 165      _intialize_event_loop.  */
 166   ui->call_readline = gdb_readline_no_editing_callback;
 167   ui->input_handler = mi_execute_command_input_handler;
 168   async_command_editing_p = 0;
 169   /* FIXME: This is a total hack for now.  PB's use of the MI
 170      implicitly relies on a bug in the async support which allows
 171      asynchronous commands to leak through the commmand loop.  The bug
 172      involves (but is not limited to) the fact that sync_execution was
 173      erroneously initialized to 0.  Duplicate by initializing it thus
 174      here...  */
 175   sync_execution = 0;
 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, stdin == ui->instream);
 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     {
 307       fputs_unfiltered ("(gdb) \n", raw_stdout);
 308       gdb_flush (raw_stdout);
 309     }
 310 }
 311
 312 /* mi_execute_command_wrapper wrapper suitable for INPUT_HANDLER.  */
 313
 314 static void
 315 mi_execute_command_input_handler (char *cmd)
 316 {
 317   mi_execute_command_wrapper (cmd);
 318
 319   /* Print a prompt, indicating we're ready for further input, unless
 320      we just started a synchronous command.  In that case, we're about
 321      to go back to the event loop and will output the prompt in the
 322      'synchronous_command_done' observer when the target next
 323      stops.  */
 324   if (!sync_execution)
 325     {
 326       fputs_unfiltered ("(gdb) \n", raw_stdout);
 327       gdb_flush (raw_stdout);
 328     }
 329 }
 330
 331 static void
 332 mi_command_loop (void *data)
 333 {
 334   /* Turn off 8 bit strings in quoted output.  Any character with the
 335      high bit set is printed using C's octal format.  */
 336   sevenbit_strings = 1;
 337
 338   /* Tell the world that we're alive.  */
 339   fputs_unfiltered ("(gdb) \n", raw_stdout);
 340   gdb_flush (raw_stdout);
 341
 342   start_event_loop ();
 343 }
 344
 345 static void
 346 mi_new_thread (struct thread_info *t)
 347 {
 348   struct inferior *inf = find_inferior_ptid (t->ptid);
 349   struct switch_thru_all_uis state;
 350
 351   gdb_assert (inf);
 352
 353   SWITCH_THRU_ALL_UIS (state)
 354     {
 355       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
 356       struct cleanup *old_chain;
 357
 358       if (mi == NULL)
 359         continue;
 360
 361       old_chain = make_cleanup_restore_target_terminal ();
 362       target_terminal_ours_for_output ();
 363
 364       fprintf_unfiltered (mi->event_channel,
 365                           "thread-created,id=\"%d\",group-id=\"i%d\"",
 366                           t->global_num, inf->num);
 367       gdb_flush (mi->event_channel);
 368
 369       do_cleanups (old_chain);
 370     }
 371 }
 372
 373 static void
 374 mi_thread_exit (struct thread_info *t, int silent)
 375 {
 376   struct switch_thru_all_uis state;
 377
 378   if (silent)
 379     return;
 380
 381   SWITCH_THRU_ALL_UIS (state)
 382     {
 383       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
 384       struct cleanup *old_chain;
 385
 386       if (mi == NULL)
 387         continue;
 388
 389       old_chain = make_cleanup_restore_target_terminal ();
 390       target_terminal_ours_for_output ();
 391       fprintf_unfiltered (mi->event_channel,
 392                           "thread-exited,id=\"%d\",group-id=\"i%d\"",
 393                           t->global_num, t->inf->num);
 394       gdb_flush (mi->event_channel);
 395
 396       do_cleanups (old_chain);
 397     }
 398 }
 399
 400 /* Emit notification on changing the state of record.  */
 401
 402 static void
 403 mi_record_changed (struct inferior *inferior, int started, const char *method,
 404                    const char *format)
 405 {
 406   struct switch_thru_all_uis state;
 407
 408   SWITCH_THRU_ALL_UIS (state)
 409     {
 410       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
 411       struct cleanup *old_chain;
 412
 413       if (mi == NULL)
 414         continue;
 415
 416       old_chain = make_cleanup_restore_target_terminal ();
 417       target_terminal_ours_for_output ();
 418
 419       if (started)
 420         {
 421           if (format != NULL)
 422             {
 423               fprintf_unfiltered (mi->event_channel,
 424                                   "record-started,thread-group=\"i%d\","
 425                                   "method=\"%s\",format=\"%s\"",
 426                                   inferior->num, method, format);
 427             }
 428           else
 429             {
 430               fprintf_unfiltered (mi->event_channel,
 431                                   "record-started,thread-group=\"i%d\","
 432                                   "method=\"%s\"",
 433                                   inferior->num, method);
 434             }
 435         }
 436       else
 437         {
 438           fprintf_unfiltered (mi->event_channel,
 439                               "record-stopped,thread-group=\"i%d\"",
 440                               inferior->num);
 441         }
 442
 443       gdb_flush (mi->event_channel);
 444
 445       do_cleanups (old_chain);
 446     }
 447 }
 448
 449 static void
 450 mi_inferior_added (struct inferior *inf)
 451 {
 452   struct switch_thru_all_uis state;
 453
 454   SWITCH_THRU_ALL_UIS (state)
 455     {
 456       struct interp *interp;
 457       struct mi_interp *mi;
 458       struct cleanup *old_chain;
 459
 460       /* We'll be called once for the initial inferior, before the top
 461          level interpreter is set.  */
 462       interp = top_level_interpreter ();
 463       if (interp == NULL)
 464         continue;
 465
 466       mi = as_mi_interp (interp);
 467       if (mi == NULL)
 468         continue;
 469
 470       old_chain = make_cleanup_restore_target_terminal ();
 471       target_terminal_ours_for_output ();
 472
 473       fprintf_unfiltered (mi->event_channel,
 474                           "thread-group-added,id=\"i%d\"",
 475                           inf->num);
 476       gdb_flush (mi->event_channel);
 477
 478       do_cleanups (old_chain);
 479     }
 480 }
 481
 482 static void
 483 mi_inferior_appeared (struct inferior *inf)
 484 {
 485   struct switch_thru_all_uis state;
 486
 487   SWITCH_THRU_ALL_UIS (state)
 488     {
 489       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
 490       struct cleanup *old_chain;
 491
 492       if (mi == NULL)
 493         continue;
 494
 495       old_chain = make_cleanup_restore_target_terminal ();
 496       target_terminal_ours_for_output ();
 497
 498       fprintf_unfiltered (mi->event_channel,
 499                           "thread-group-started,id=\"i%d\",pid=\"%d\"",
 500                           inf->num, inf->pid);
 501       gdb_flush (mi->event_channel);
 502       do_cleanups (old_chain);
 503     }
 504 }
 505
 506 static void
 507 mi_inferior_exit (struct inferior *inf)
 508 {
 509   struct switch_thru_all_uis state;
 510
 511   SWITCH_THRU_ALL_UIS (state)
 512     {
 513       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
 514       struct cleanup *old_chain;
 515
 516       if (mi == NULL)
 517         continue;
 518
 519       old_chain = make_cleanup_restore_target_terminal ();
 520       target_terminal_ours_for_output ();
 521
 522       if (inf->has_exit_code)
 523         fprintf_unfiltered (mi->event_channel,
 524                             "thread-group-exited,id=\"i%d\",exit-code=\"%s\"",
 525                             inf->num, int_string (inf->exit_code, 8, 0, 0, 1));
 526       else
 527         fprintf_unfiltered (mi->event_channel,
 528                             "thread-group-exited,id=\"i%d\"", inf->num);
 529
 530       gdb_flush (mi->event_channel);
 531       do_cleanups (old_chain);
 532     }
 533 }
 534
 535 static void
 536 mi_inferior_removed (struct inferior *inf)
 537 {
 538   struct switch_thru_all_uis state;
 539
 540   SWITCH_THRU_ALL_UIS (state)
 541     {
 542       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
 543       struct cleanup *old_chain;
 544
 545       if (mi == NULL)
 546         continue;
 547
 548       old_chain = make_cleanup_restore_target_terminal ();
 549       target_terminal_ours_for_output ();
 550
 551       fprintf_unfiltered (mi->event_channel,
 552                           "thread-group-removed,id=\"i%d\"",
 553                           inf->num);
 554       gdb_flush (mi->event_channel);
 555
 556       do_cleanups (old_chain);
 557     }
 558 }
 559
 560 /* Return the MI interpreter, if it is active -- either because it's
 561    the top-level interpreter or the interpreter executing the current
 562    command.  Returns NULL if the MI interpreter is not being used.  */
 563
 564 static struct mi_interp *
 565 find_mi_interp (void)
 566 {
 567   struct mi_interp *mi;
 568
 569   mi = as_mi_interp (top_level_interpreter ());
 570   if (mi != NULL)
 571     return mi;
 572
 573   mi = as_mi_interp (command_interp ());
 574   if (mi != NULL)
 575     return mi;
 576
 577   return NULL;
 578 }
 579
 580 /* Observers for several run control events that print why the
 581    inferior has stopped to both the the MI event channel and to the MI
 582    console.  If the MI interpreter is not active, print nothing.  */
 583
 584 /* Observer for the signal_received notification.  */
 585
 586 static void
 587 mi_on_signal_received (enum gdb_signal siggnal)
 588 {
 589   struct switch_thru_all_uis state;
 590
 591   SWITCH_THRU_ALL_UIS (state)
 592     {
 593       struct mi_interp *mi = find_mi_interp ();
 594
 595       if (mi == NULL)
 596         continue;
 597
 598       print_signal_received_reason (mi->mi_uiout, siggnal);
 599       print_signal_received_reason (mi->cli_uiout, siggnal);
 600     }
 601 }
 602
 603 /* Observer for the end_stepping_range notification.  */
 604
 605 static void
 606 mi_on_end_stepping_range (void)
 607 {
 608   struct switch_thru_all_uis state;
 609
 610   SWITCH_THRU_ALL_UIS (state)
 611     {
 612       struct mi_interp *mi = find_mi_interp ();
 613
 614       if (mi == NULL)
 615         continue;
 616
 617       print_end_stepping_range_reason (mi->mi_uiout);
 618       print_end_stepping_range_reason (mi->cli_uiout);
 619     }
 620 }
 621
 622 /* Observer for the signal_exited notification.  */
 623
 624 static void
 625 mi_on_signal_exited (enum gdb_signal siggnal)
 626 {
 627   struct switch_thru_all_uis state;
 628
 629   SWITCH_THRU_ALL_UIS (state)
 630     {
 631       struct mi_interp *mi = find_mi_interp ();
 632
 633       if (mi == NULL)
 634         continue;
 635
 636       print_signal_exited_reason (mi->mi_uiout, siggnal);
 637       print_signal_exited_reason (mi->cli_uiout, siggnal);
 638     }
 639 }
 640
 641 /* Observer for the exited notification.  */
 642
 643 static void
 644 mi_on_exited (int exitstatus)
 645 {
 646   struct switch_thru_all_uis state;
 647
 648   SWITCH_THRU_ALL_UIS (state)
 649     {
 650       struct mi_interp *mi = find_mi_interp ();
 651
 652       if (mi == NULL)
 653         continue;
 654
 655       print_exited_reason (mi->mi_uiout, exitstatus);
 656       print_exited_reason (mi->cli_uiout, exitstatus);
 657     }
 658 }
 659
 660 /* Observer for the no_history notification.  */
 661
 662 static void
 663 mi_on_no_history (void)
 664 {
 665   struct switch_thru_all_uis state;
 666
 667   SWITCH_THRU_ALL_UIS (state)
 668     {
 669       struct mi_interp *mi = find_mi_interp ();
 670
 671       if (mi == NULL)
 672         continue;
 673
 674       print_no_history_reason (mi->mi_uiout);
 675       print_no_history_reason (mi->cli_uiout);
 676     }
 677 }
 678
 679 static void
 680 mi_on_normal_stop_1 (struct bpstats *bs, int print_frame)
 681 {
 682   /* Since this can be called when CLI command is executing,
 683      using cli interpreter, be sure to use MI uiout for output,
 684      not the current one.  */
 685   struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
 686
 687   if (print_frame)
 688     {
 689       struct thread_info *tp;
 690       int core;
 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       /* Breakpoint hits should always be mirrored to the console.
 706          Deciding what to mirror to the console wrt to breakpoints and
 707          random stops gets messy real fast.  E.g., say "s" trips on a
 708          breakpoint.  We'd clearly want to mirror the event to the
 709          console in this case.  But what about more complicated cases
 710          like "s&; thread n; s&", and one of those steps spawning a
 711          new thread, and that thread hitting a breakpoint?  It's
 712          impossible in general to track whether the thread had any
 713          relation to the commands that had been executed.  So we just
 714          simplify and always mirror breakpoints and random events to
 715          the console.
 716
 717          OTOH, we should print the source line to the console when
 718          stepping or other similar commands, iff the step was started
 719          by a console command, but not if it was started with
 720          -exec-step or similar.  */
 721       if ((bpstat_what (tp->control.stop_bpstat).main_action
 722            == BPSTAT_WHAT_STOP_NOISY)
 723           || !(tp->thread_fsm != NULL
 724                && thread_fsm_finished_p (tp->thread_fsm))
 725           || (tp->control.command_interp != NULL
 726               && tp->control.command_interp != top_level_interpreter ()))
 727         {
 728           struct mi_interp *mi
 729             = (struct mi_interp *) top_level_interpreter_data ();
 730
 731           print_stop_event (mi->cli_uiout);
 732         }
 733
 734       tp = inferior_thread ();
 735       ui_out_field_int (mi_uiout, "thread-id", tp->global_num);
 736       if (non_stop)
 737         {
 738           struct cleanup *back_to = make_cleanup_ui_out_list_begin_end
 739             (mi_uiout, "stopped-threads");
 740
 741           ui_out_field_int (mi_uiout, NULL, tp->global_num);
 742           do_cleanups (back_to);
 743         }
 744       else
 745         ui_out_field_string (mi_uiout, "stopped-threads", "all");
 746
 747       core = target_core_of_thread (inferior_ptid);
 748       if (core != -1)
 749         ui_out_field_int (mi_uiout, "core", core);
 750     }
 751
 752   fputs_unfiltered ("*stopped", raw_stdout);
 753   mi_out_put (mi_uiout, raw_stdout);
 754   mi_out_rewind (mi_uiout);
 755   mi_print_timing_maybe ();
 756   fputs_unfiltered ("\n", raw_stdout);
 757   gdb_flush (raw_stdout);
 758 }
 759
 760 static void
 761 mi_on_normal_stop (struct bpstats *bs, int print_frame)
 762 {
 763   struct switch_thru_all_uis state;
 764
 765   SWITCH_THRU_ALL_UIS (state)
 766     {
 767       if (as_mi_interp (top_level_interpreter ()) == NULL)
 768         continue;
 769
 770       mi_on_normal_stop_1 (bs, print_frame);
 771     }
 772 }
 773
 774 static void
 775 mi_about_to_proceed (void)
 776 {
 777   /* Suppress output while calling an inferior function.  */
 778
 779   if (!ptid_equal (inferior_ptid, null_ptid))
 780     {
 781       struct thread_info *tp = inferior_thread ();
 782
 783       if (tp->control.in_infcall)
 784         return;
 785     }
 786
 787   mi_proceeded = 1;
 788 }
 789
 790 /* When the element is non-zero, no MI notifications will be emitted in
 791    response to the corresponding observers.  */
 792
 793 struct mi_suppress_notification mi_suppress_notification =
 794   {
 795     0,
 796     0,
 797     0,
 798   };
 799
 800 /* Emit notification on changing a traceframe.  */
 801
 802 static void
 803 mi_traceframe_changed (int tfnum, int tpnum)
 804 {
 805   struct switch_thru_all_uis state;
 806
 807   if (mi_suppress_notification.traceframe)
 808     return;
 809
 810   SWITCH_THRU_ALL_UIS (state)
 811     {
 812       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
 813       struct cleanup *old_chain;
 814
 815       if (mi == NULL)
 816         continue;
 817
 818       old_chain = make_cleanup_restore_target_terminal ();
 819       target_terminal_ours_for_output ();
 820
 821       if (tfnum >= 0)
 822         fprintf_unfiltered (mi->event_channel, "traceframe-changed,"
 823                             "num=\"%d\",tracepoint=\"%d\"\n",
 824                             tfnum, tpnum);
 825       else
 826         fprintf_unfiltered (mi->event_channel, "traceframe-changed,end");
 827
 828       gdb_flush (mi->event_channel);
 829
 830       do_cleanups (old_chain);
 831     }
 832 }
 833
 834 /* Emit notification on creating a trace state variable.  */
 835
 836 static void
 837 mi_tsv_created (const struct trace_state_variable *tsv)
 838 {
 839   struct switch_thru_all_uis state;
 840
 841   SWITCH_THRU_ALL_UIS (state)
 842     {
 843       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
 844       struct cleanup *old_chain;
 845
 846       if (mi == NULL)
 847         continue;
 848
 849       old_chain = make_cleanup_restore_target_terminal ();
 850       target_terminal_ours_for_output ();
 851
 852       fprintf_unfiltered (mi->event_channel, "tsv-created,"
 853                           "name=\"%s\",initial=\"%s\"\n",
 854                           tsv->name, plongest (tsv->initial_value));
 855
 856       gdb_flush (mi->event_channel);
 857
 858       do_cleanups (old_chain);
 859     }
 860 }
 861
 862 /* Emit notification on deleting a trace state variable.  */
 863
 864 static void
 865 mi_tsv_deleted (const struct trace_state_variable *tsv)
 866 {
 867   struct switch_thru_all_uis state;
 868
 869   SWITCH_THRU_ALL_UIS (state)
 870     {
 871       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
 872       struct cleanup *old_chain;
 873
 874       if (mi == NULL)
 875         continue;
 876
 877       old_chain = make_cleanup_restore_target_terminal ();
 878       target_terminal_ours_for_output ();
 879
 880       if (tsv != NULL)
 881         fprintf_unfiltered (mi->event_channel, "tsv-deleted,"
 882                             "name=\"%s\"\n", tsv->name);
 883       else
 884         fprintf_unfiltered (mi->event_channel, "tsv-deleted\n");
 885
 886       gdb_flush (mi->event_channel);
 887
 888       do_cleanups (old_chain);
 889     }
 890 }
 891
 892 /* Emit notification on modifying a trace state variable.  */
 893
 894 static void
 895 mi_tsv_modified (const struct trace_state_variable *tsv)
 896 {
 897   struct switch_thru_all_uis state;
 898
 899   SWITCH_THRU_ALL_UIS (state)
 900     {
 901       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
 902       struct ui_out *mi_uiout;
 903       struct cleanup *old_chain;
 904
 905       if (mi == NULL)
 906         continue;
 907
 908       mi_uiout = interp_ui_out (top_level_interpreter ());
 909
 910       old_chain = make_cleanup_restore_target_terminal ();
 911       target_terminal_ours_for_output ();
 912
 913       fprintf_unfiltered (mi->event_channel,
 914                           "tsv-modified");
 915
 916       ui_out_redirect (mi_uiout, mi->event_channel);
 917
 918       ui_out_field_string (mi_uiout, "name", tsv->name);
 919       ui_out_field_string (mi_uiout, "initial",
 920                            plongest (tsv->initial_value));
 921       if (tsv->value_known)
 922         ui_out_field_string (mi_uiout, "current", plongest (tsv->value));
 923
 924       ui_out_redirect (mi_uiout, NULL);
 925
 926       gdb_flush (mi->event_channel);
 927
 928       do_cleanups (old_chain);
 929     }
 930 }
 931
 932 /* Emit notification about a created breakpoint.  */
 933
 934 static void
 935 mi_breakpoint_created (struct breakpoint *b)
 936 {
 937   struct switch_thru_all_uis state;
 938
 939   if (mi_suppress_notification.breakpoint)
 940     return;
 941
 942   if (b->number <= 0)
 943     return;
 944
 945   SWITCH_THRU_ALL_UIS (state)
 946     {
 947       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
 948       struct ui_out *mi_uiout;
 949       struct cleanup *old_chain;
 950
 951       if (mi == NULL)
 952         continue;
 953
 954       mi_uiout = interp_ui_out (top_level_interpreter ());
 955
 956       old_chain = make_cleanup_restore_target_terminal ();
 957       target_terminal_ours_for_output ();
 958
 959       fprintf_unfiltered (mi->event_channel,
 960                           "breakpoint-created");
 961       /* We want the output from gdb_breakpoint_query to go to
 962          mi->event_channel.  One approach would be to just call
 963          gdb_breakpoint_query, and then use mi_out_put to send the current
 964          content of mi_outout into mi->event_channel.  However, that will
 965          break if anything is output to mi_uiout prior to calling the
 966          breakpoint_created notifications.  So, we use
 967          ui_out_redirect.  */
 968       ui_out_redirect (mi_uiout, mi->event_channel);
 969       TRY
 970         {
 971           gdb_breakpoint_query (mi_uiout, b->number, NULL);
 972         }
 973       CATCH (e, RETURN_MASK_ERROR)
 974         {
 975         }
 976       END_CATCH
 977
 978       ui_out_redirect (mi_uiout, NULL);
 979
 980       gdb_flush (mi->event_channel);
 981
 982       do_cleanups (old_chain);
 983     }
 984 }
 985
 986 /* Emit notification about deleted breakpoint.  */
 987
 988 static void
 989 mi_breakpoint_deleted (struct breakpoint *b)
 990 {
 991   struct switch_thru_all_uis state;
 992
 993   if (mi_suppress_notification.breakpoint)
 994     return;
 995
 996   if (b->number <= 0)
 997     return;
 998
 999   SWITCH_THRU_ALL_UIS (state)
1000     {
1001       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
1002       struct cleanup *old_chain;
1003
1004       if (mi == NULL)
1005         continue;
1006
1007       old_chain = make_cleanup_restore_target_terminal ();
1008       target_terminal_ours_for_output ();
1009
1010       fprintf_unfiltered (mi->event_channel, "breakpoint-deleted,id=\"%d\"",
1011                           b->number);
1012
1013       gdb_flush (mi->event_channel);
1014
1015       do_cleanups (old_chain);
1016     }
1017 }
1018
1019 /* Emit notification about modified breakpoint.  */
1020
1021 static void
1022 mi_breakpoint_modified (struct breakpoint *b)
1023 {
1024   struct switch_thru_all_uis state;
1025
1026   if (mi_suppress_notification.breakpoint)
1027     return;
1028
1029   if (b->number <= 0)
1030     return;
1031
1032   SWITCH_THRU_ALL_UIS (state)
1033     {
1034       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
1035       struct cleanup *old_chain;
1036
1037       if (mi == NULL)
1038         continue;
1039
1040       old_chain = make_cleanup_restore_target_terminal ();
1041       target_terminal_ours_for_output ();
1042       fprintf_unfiltered (mi->event_channel,
1043                           "breakpoint-modified");
1044       /* We want the output from gdb_breakpoint_query to go to
1045          mi->event_channel.  One approach would be to just call
1046          gdb_breakpoint_query, and then use mi_out_put to send the current
1047          content of mi_outout into mi->event_channel.  However, that will
1048          break if anything is output to mi_uiout prior to calling the
1049          breakpoint_created notifications.  So, we use
1050          ui_out_redirect.  */
1051       ui_out_redirect (mi->mi_uiout, mi->event_channel);
1052       TRY
1053         {
1054           gdb_breakpoint_query (mi->mi_uiout, b->number, NULL);
1055         }
1056       CATCH (e, RETURN_MASK_ERROR)
1057         {
1058         }
1059       END_CATCH
1060
1061       ui_out_redirect (mi->mi_uiout, NULL);
1062
1063       gdb_flush (mi->event_channel);
1064
1065       do_cleanups (old_chain);
1066     }
1067 }
1068
1069 static int
1070 mi_output_running_pid (struct thread_info *info, void *arg)
1071 {
1072   ptid_t *ptid = (ptid_t *) arg;
1073   struct switch_thru_all_uis state;
1074
1075   SWITCH_THRU_ALL_UIS (state)
1076     {
1077       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
1078
1079       if (mi == NULL)
1080         continue;
1081
1082       if (ptid_get_pid (*ptid) == ptid_get_pid (info->ptid))
1083         fprintf_unfiltered (raw_stdout,
1084                             "*running,thread-id=\"%d\"\n",
1085                             info->global_num);
1086     }
1087
1088   return 0;
1089 }
1090
1091 static int
1092 mi_inferior_count (struct inferior *inf, void *arg)
1093 {
1094   if (inf->pid != 0)
1095     {
1096       int *count_p = (int *) arg;
1097       (*count_p)++;
1098     }
1099
1100   return 0;
1101 }
1102
1103 static void
1104 mi_on_resume_1 (ptid_t ptid)
1105 {
1106   /* To cater for older frontends, emit ^running, but do it only once
1107      per each command.  We do it here, since at this point we know
1108      that the target was successfully resumed, and in non-async mode,
1109      we won't return back to MI interpreter code until the target
1110      is done running, so delaying the output of "^running" until then
1111      will make it impossible for frontend to know what's going on.
1112
1113      In future (MI3), we'll be outputting "^done" here.  */
1114   if (!running_result_record_printed && mi_proceeded)
1115     {
1116       fprintf_unfiltered (raw_stdout, "%s^running\n",
1117                           current_token ? current_token : "");
1118     }
1119
1120   if (ptid_get_pid (ptid) == -1)
1121     fprintf_unfiltered (raw_stdout, "*running,thread-id=\"all\"\n");
1122   else if (ptid_is_pid (ptid))
1123     {
1124       int count = 0;
1125
1126       /* Backwards compatibility.  If there's only one inferior,
1127          output "all", otherwise, output each resumed thread
1128          individually.  */
1129       iterate_over_inferiors (mi_inferior_count, &count);
1130
1131       if (count == 1)
1132         fprintf_unfiltered (raw_stdout, "*running,thread-id=\"all\"\n");
1133       else
1134         iterate_over_threads (mi_output_running_pid, &ptid);
1135     }
1136   else
1137     {
1138       struct thread_info *ti = find_thread_ptid (ptid);
1139
1140       gdb_assert (ti);
1141       fprintf_unfiltered (raw_stdout, "*running,thread-id=\"%d\"\n",
1142                           ti->global_num);
1143     }
1144
1145   if (!running_result_record_printed && mi_proceeded)
1146     {
1147       running_result_record_printed = 1;
1148       /* This is what gdb used to do historically -- printing prompt even if
1149          it cannot actually accept any input.  This will be surely removed
1150          for MI3, and may be removed even earlier.  SYNC_EXECUTION is
1151          checked here because we only need to emit a prompt if a
1152          synchronous command was issued when the target is async.  */
1153       if (!target_can_async_p () || sync_execution)
1154         fputs_unfiltered ("(gdb) \n", raw_stdout);
1155     }
1156   gdb_flush (raw_stdout);
1157 }
1158
1159 static void
1160 mi_on_resume (ptid_t ptid)
1161 {
1162   struct thread_info *tp = NULL;
1163   struct switch_thru_all_uis state;
1164
1165   if (ptid_equal (ptid, minus_one_ptid) || ptid_is_pid (ptid))
1166     tp = inferior_thread ();
1167   else
1168     tp = find_thread_ptid (ptid);
1169
1170   /* Suppress output while calling an inferior function.  */
1171   if (tp->control.in_infcall)
1172     return;
1173
1174   SWITCH_THRU_ALL_UIS (state)
1175     {
1176       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
1177       struct cleanup *old_chain;
1178
1179       if (mi == NULL)
1180         continue;
1181
1182       old_chain = make_cleanup_restore_target_terminal ();
1183       target_terminal_ours_for_output ();
1184
1185       mi_on_resume_1 (ptid);
1186
1187       do_cleanups (old_chain);
1188     }
1189 }
1190
1191 static void
1192 mi_solib_loaded (struct so_list *solib)
1193 {
1194   struct switch_thru_all_uis state;
1195
1196   SWITCH_THRU_ALL_UIS (state)
1197     {
1198       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
1199       struct ui_out *uiout;
1200       struct cleanup *old_chain;
1201
1202       if (mi == NULL)
1203         continue;
1204
1205       uiout = interp_ui_out (top_level_interpreter ());
1206
1207       old_chain = make_cleanup_restore_target_terminal ();
1208       target_terminal_ours_for_output ();
1209
1210       fprintf_unfiltered (mi->event_channel, "library-loaded");
1211
1212       ui_out_redirect (uiout, mi->event_channel);
1213
1214       ui_out_field_string (uiout, "id", solib->so_original_name);
1215       ui_out_field_string (uiout, "target-name", solib->so_original_name);
1216       ui_out_field_string (uiout, "host-name", solib->so_name);
1217       ui_out_field_int (uiout, "symbols-loaded", solib->symbols_loaded);
1218       if (!gdbarch_has_global_solist (target_gdbarch ()))
1219         {
1220           ui_out_field_fmt (uiout, "thread-group", "i%d",
1221                             current_inferior ()->num);
1222         }
1223
1224       ui_out_redirect (uiout, NULL);
1225
1226       gdb_flush (mi->event_channel);
1227
1228       do_cleanups (old_chain);
1229     }
1230 }
1231
1232 static void
1233 mi_solib_unloaded (struct so_list *solib)
1234 {
1235   struct switch_thru_all_uis state;
1236
1237   SWITCH_THRU_ALL_UIS (state)
1238     {
1239       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
1240       struct ui_out *uiout;
1241       struct cleanup *old_chain;
1242
1243       if (mi == NULL)
1244         continue;
1245
1246       uiout = interp_ui_out (top_level_interpreter ());
1247
1248       old_chain = make_cleanup_restore_target_terminal ();
1249       target_terminal_ours_for_output ();
1250
1251       fprintf_unfiltered (mi->event_channel, "library-unloaded");
1252
1253       ui_out_redirect (uiout, mi->event_channel);
1254
1255       ui_out_field_string (uiout, "id", solib->so_original_name);
1256       ui_out_field_string (uiout, "target-name", solib->so_original_name);
1257       ui_out_field_string (uiout, "host-name", solib->so_name);
1258       if (!gdbarch_has_global_solist (target_gdbarch ()))
1259         {
1260           ui_out_field_fmt (uiout, "thread-group", "i%d",
1261                             current_inferior ()->num);
1262         }
1263
1264       ui_out_redirect (uiout, NULL);
1265
1266       gdb_flush (mi->event_channel);
1267
1268       do_cleanups (old_chain);
1269     }
1270 }
1271
1272 /* Emit notification about the command parameter change.  */
1273
1274 static void
1275 mi_command_param_changed (const char *param, const char *value)
1276 {
1277   struct switch_thru_all_uis state;
1278
1279   if (mi_suppress_notification.cmd_param_changed)
1280     return;
1281
1282   SWITCH_THRU_ALL_UIS (state)
1283     {
1284       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
1285       struct ui_out *mi_uiout;
1286       struct cleanup *old_chain;
1287
1288       if (mi == NULL)
1289         continue;
1290
1291       mi_uiout = interp_ui_out (top_level_interpreter ());
1292
1293       old_chain = make_cleanup_restore_target_terminal ();
1294       target_terminal_ours_for_output ();
1295
1296       fprintf_unfiltered (mi->event_channel, "cmd-param-changed");
1297
1298       ui_out_redirect (mi_uiout, mi->event_channel);
1299
1300       ui_out_field_string (mi_uiout, "param", param);
1301       ui_out_field_string (mi_uiout, "value", value);
1302
1303       ui_out_redirect (mi_uiout, NULL);
1304
1305       gdb_flush (mi->event_channel);
1306
1307       do_cleanups (old_chain);
1308     }
1309 }
1310
1311 /* Emit notification about the target memory change.  */
1312
1313 static void
1314 mi_memory_changed (struct inferior *inferior, CORE_ADDR memaddr,
1315                    ssize_t len, const bfd_byte *myaddr)
1316 {
1317   struct switch_thru_all_uis state;
1318
1319   if (mi_suppress_notification.memory)
1320     return;
1321
1322   SWITCH_THRU_ALL_UIS (state)
1323     {
1324       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
1325       struct ui_out *mi_uiout;
1326       struct obj_section *sec;
1327       struct cleanup *old_chain;
1328
1329       if (mi == NULL)
1330         continue;
1331
1332       mi_uiout = interp_ui_out (top_level_interpreter ());
1333
1334       old_chain = make_cleanup_restore_target_terminal ();
1335       target_terminal_ours_for_output ();
1336
1337       fprintf_unfiltered (mi->event_channel, "memory-changed");
1338
1339       ui_out_redirect (mi_uiout, mi->event_channel);
1340
1341       ui_out_field_fmt (mi_uiout, "thread-group", "i%d", inferior->num);
1342       ui_out_field_core_addr (mi_uiout, "addr", target_gdbarch (), memaddr);
1343       ui_out_field_fmt (mi_uiout, "len", "%s", hex_string (len));
1344
1345       /* Append 'type=code' into notification if MEMADDR falls in the range of
1346          sections contain code.  */
1347       sec = find_pc_section (memaddr);
1348       if (sec != NULL && sec->objfile != NULL)
1349         {
1350           flagword flags = bfd_get_section_flags (sec->objfile->obfd,
1351                                                   sec->the_bfd_section);
1352
1353           if (flags & SEC_CODE)
1354             ui_out_field_string (mi_uiout, "type", "code");
1355         }
1356
1357       ui_out_redirect (mi_uiout, NULL);
1358
1359       gdb_flush (mi->event_channel);
1360
1361       do_cleanups (old_chain);
1362     }
1363 }
1364
1365 static int
1366 report_initial_inferior (struct inferior *inf, void *closure)
1367 {
1368   /* This function is called from mi_interpreter_init, and since
1369      mi_inferior_added assumes that inferior is fully initialized
1370      and top_level_interpreter_data is set, we cannot call
1371      it here.  */
1372   struct mi_interp *mi = (struct mi_interp *) closure;
1373   struct cleanup *old_chain;
1374
1375   old_chain = make_cleanup_restore_target_terminal ();
1376   target_terminal_ours_for_output ();
1377
1378   fprintf_unfiltered (mi->event_channel,
1379                       "thread-group-added,id=\"i%d\"",
1380                       inf->num);
1381   gdb_flush (mi->event_channel);
1382
1383   do_cleanups (old_chain);
1384   return 0;
1385 }
1386
1387 static struct ui_out *
1388 mi_ui_out (struct interp *interp)
1389 {
1390   struct mi_interp *mi = (struct mi_interp *) interp_data (interp);
1391
1392   return mi->mi_uiout;
1393 }
1394
1395 /* Save the original value of raw_stdout here when logging, so we can
1396    restore correctly when done.  */
1397
1398 static struct ui_file *saved_raw_stdout;
1399
1400 /* Do MI-specific logging actions; save raw_stdout, and change all
1401    the consoles to use the supplied ui-file(s).  */
1402
1403 static int
1404 mi_set_logging (struct interp *interp, int start_log,
1405                 struct ui_file *out, struct ui_file *logfile)
1406 {
1407   struct mi_interp *mi = (struct mi_interp *) interp_data (interp);
1408
1409   if (!mi)
1410     return 0;
1411
1412   if (start_log)
1413     {
1414       /* The tee created already is based on gdb_stdout, which for MI
1415          is a console and so we end up in an infinite loop of console
1416          writing to ui_file writing to console etc.  So discard the
1417          existing tee (it hasn't been used yet, and MI won't ever use
1418          it), and create one based on raw_stdout instead.  */
1419       if (logfile)
1420         {
1421           ui_file_delete (out);
1422           out = tee_file_new (raw_stdout, 0, logfile, 0);
1423         }
1424
1425       saved_raw_stdout = raw_stdout;
1426       raw_stdout = out;
1427     }
1428   else
1429     {
1430       raw_stdout = saved_raw_stdout;
1431       saved_raw_stdout = NULL;
1432     }
1433
1434   mi_console_set_raw (mi->out, raw_stdout);
1435   mi_console_set_raw (mi->err, raw_stdout);
1436   mi_console_set_raw (mi->log, raw_stdout);
1437   mi_console_set_raw (mi->targ, raw_stdout);
1438   mi_console_set_raw (mi->event_channel, raw_stdout);
1439
1440   return 1;
1441 }
1442
1443 /* The MI interpreter's vtable.  */
1444
1445 static const struct interp_procs mi_interp_procs =
1446 {
1447   mi_interpreter_init,          /* init_proc */
1448   mi_interpreter_resume,        /* resume_proc */
1449   mi_interpreter_suspend,       /* suspend_proc */
1450   mi_interpreter_exec,          /* exec_proc */
1451   mi_ui_out,                    /* ui_out_proc */
1452   mi_set_logging,               /* set_logging_proc */
1453   mi_command_loop               /* command_loop_proc */
1454 };
1455
1456 /* Factory for MI interpreters.  */
1457
1458 static struct interp *
1459 mi_interp_factory (const char *name)
1460 {
1461   return interp_new (name, &mi_interp_procs, NULL);
1462 }
1463
1464 extern initialize_file_ftype _initialize_mi_interp; /* -Wmissing-prototypes */
1465
1466 void
1467 _initialize_mi_interp (void)
1468 {
1469   /* The various interpreter levels.  */
1470   interp_factory_register (INTERP_MI1, mi_interp_factory);
1471   interp_factory_register (INTERP_MI2, mi_interp_factory);
1472   interp_factory_register (INTERP_MI3, mi_interp_factory);
1473   interp_factory_register (INTERP_MI, mi_interp_factory);
1474
1475   observer_attach_signal_received (mi_on_signal_received);
1476   observer_attach_end_stepping_range (mi_on_end_stepping_range);
1477   observer_attach_signal_exited (mi_on_signal_exited);
1478   observer_attach_exited (mi_on_exited);
1479   observer_attach_no_history (mi_on_no_history);
1480   observer_attach_new_thread (mi_new_thread);
1481   observer_attach_thread_exit (mi_thread_exit);
1482   observer_attach_inferior_added (mi_inferior_added);
1483   observer_attach_inferior_appeared (mi_inferior_appeared);
1484   observer_attach_inferior_exit (mi_inferior_exit);
1485   observer_attach_inferior_removed (mi_inferior_removed);
1486   observer_attach_record_changed (mi_record_changed);
1487   observer_attach_normal_stop (mi_on_normal_stop);
1488   observer_attach_target_resumed (mi_on_resume);
1489   observer_attach_solib_loaded (mi_solib_loaded);
1490   observer_attach_solib_unloaded (mi_solib_unloaded);
1491   observer_attach_about_to_proceed (mi_about_to_proceed);
1492   observer_attach_traceframe_changed (mi_traceframe_changed);
1493   observer_attach_tsv_created (mi_tsv_created);
1494   observer_attach_tsv_deleted (mi_tsv_deleted);
1495   observer_attach_tsv_modified (mi_tsv_modified);
1496   observer_attach_breakpoint_created (mi_breakpoint_created);
1497   observer_attach_breakpoint_deleted (mi_breakpoint_deleted);
1498   observer_attach_breakpoint_modified (mi_breakpoint_modified);
1499   observer_attach_command_param_changed (mi_command_param_changed);
1500   observer_attach_memory_changed (mi_memory_changed);
1501   observer_attach_sync_execution_done (mi_on_sync_execution_done);
1502 }