gdb/mi/mi-interp.c

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