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