gdb/mi/mi-interp.c

   1 /* MI Interpreter Definitions and Commands for GDB, the GNU debugger.
   2
   3    Copyright (C) 2002-2013 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 "gdb_string.h"
  22 #include "interps.h"
  23 #include "event-top.h"
  24 #include "event-loop.h"
  25 #include "inferior.h"
  26 #include "ui-out.h"
  27 #include "top.h"
  28 #include "exceptions.h"
  29 #include "mi-main.h"
  30 #include "mi-cmds.h"
  31 #include "mi-out.h"
  32 #include "mi-console.h"
  33 #include "mi-common.h"
  34 #include "observer.h"
  35 #include "gdbthread.h"
  36 #include "solist.h"
  37 #include "gdb.h"
  38 #include "objfiles.h"
  39 #include "tracepoint.h"
  40
  41 /* These are the interpreter setup, etc. functions for the MI
  42    interpreter.  */
  43
  44 static void mi_execute_command_wrapper (const char *cmd);
  45 static void mi_execute_command_input_handler (char *cmd);
  46 static void mi_command_loop (int mi_version);
  47
  48 /* These are hooks that we put in place while doing interpreter_exec
  49    so we can report interesting things that happened "behind the MI's
  50    back" in this command.  */
  51
  52 static int mi_interp_query_hook (const char *ctlstr, va_list ap)
  53   ATTRIBUTE_PRINTF (1, 0);
  54
  55 static void mi3_command_loop (void);
  56 static void mi2_command_loop (void);
  57 static void mi1_command_loop (void);
  58
  59 static void mi_insert_notify_hooks (void);
  60 static void mi_remove_notify_hooks (void);
  61 static void mi_on_normal_stop (struct bpstats *bs, int print_frame);
  62
  63 static void mi_new_thread (struct thread_info *t);
  64 static void mi_thread_exit (struct thread_info *t, int silent);
  65 static void mi_record_changed (struct inferior*, int);
  66 static void mi_inferior_added (struct inferior *inf);
  67 static void mi_inferior_appeared (struct inferior *inf);
  68 static void mi_inferior_exit (struct inferior *inf);
  69 static void mi_inferior_removed (struct inferior *inf);
  70 static void mi_on_resume (ptid_t ptid);
  71 static void mi_solib_loaded (struct so_list *solib);
  72 static void mi_solib_unloaded (struct so_list *solib);
  73 static void mi_about_to_proceed (void);
  74 static void mi_traceframe_changed (int tfnum, int tpnum);
  75 static void mi_tsv_created (const struct trace_state_variable *tsv);
  76 static void mi_tsv_deleted (const struct trace_state_variable *tsv);
  77 static void mi_tsv_modified (const struct trace_state_variable *tsv);
  78 static void mi_breakpoint_created (struct breakpoint *b);
  79 static void mi_breakpoint_deleted (struct breakpoint *b);
  80 static void mi_breakpoint_modified (struct breakpoint *b);
  81 static void mi_command_param_changed (const char *param, const char *value);
  82 static void mi_memory_changed (struct inferior *inf, CORE_ADDR memaddr,
  83                                ssize_t len, const bfd_byte *myaddr);
  84
  85 static int report_initial_inferior (struct inferior *inf, void *closure);
  86
  87 static void *
  88 mi_interpreter_init (struct interp *interp, int top_level)
  89 {
  90   struct mi_interp *mi = XMALLOC (struct mi_interp);
  91   const char *name;
  92   int mi_version;
  93
  94   /* Assign the output channel created at startup to its own global,
  95      so that we can create a console channel that encapsulates and
  96      prefixes all gdb_output-type bits coming from the rest of the
  97      debugger.  */
  98
  99   raw_stdout = gdb_stdout;
 100
 101   /* Create MI console channels, each with a different prefix so they
 102      can be distinguished.  */
 103   mi->out = mi_console_file_new (raw_stdout, "~", '"');
 104   mi->err = mi_console_file_new (raw_stdout, "&", '"');
 105   mi->log = mi->err;
 106   mi->targ = mi_console_file_new (raw_stdout, "@", '"');
 107   mi->event_channel = mi_console_file_new (raw_stdout, "=", 0);
 108
 109   name = interp_name (interp);
 110   /* INTERP_MI selects the most recent released version.  "mi2" was
 111      released as part of GDB 6.0.  */
 112   if (strcmp (name, INTERP_MI) == 0)
 113     mi_version = 2;
 114   else if (strcmp (name, INTERP_MI1) == 0)
 115     mi_version = 1;
 116   else if (strcmp (name, INTERP_MI2) == 0)
 117     mi_version = 2;
 118   else if (strcmp (name, INTERP_MI3) == 0)
 119     mi_version = 3;
 120   else
 121     gdb_assert_not_reached ("unhandled MI version");
 122
 123   mi->uiout = mi_out_new (mi_version);
 124
 125   if (top_level)
 126     {
 127       observer_attach_new_thread (mi_new_thread);
 128       observer_attach_thread_exit (mi_thread_exit);
 129       observer_attach_inferior_added (mi_inferior_added);
 130       observer_attach_inferior_appeared (mi_inferior_appeared);
 131       observer_attach_inferior_exit (mi_inferior_exit);
 132       observer_attach_inferior_removed (mi_inferior_removed);
 133       observer_attach_record_changed (mi_record_changed);
 134       observer_attach_normal_stop (mi_on_normal_stop);
 135       observer_attach_target_resumed (mi_on_resume);
 136       observer_attach_solib_loaded (mi_solib_loaded);
 137       observer_attach_solib_unloaded (mi_solib_unloaded);
 138       observer_attach_about_to_proceed (mi_about_to_proceed);
 139       observer_attach_traceframe_changed (mi_traceframe_changed);
 140       observer_attach_tsv_created (mi_tsv_created);
 141       observer_attach_tsv_deleted (mi_tsv_deleted);
 142       observer_attach_tsv_modified (mi_tsv_modified);
 143       observer_attach_breakpoint_created (mi_breakpoint_created);
 144       observer_attach_breakpoint_deleted (mi_breakpoint_deleted);
 145       observer_attach_breakpoint_modified (mi_breakpoint_modified);
 146       observer_attach_command_param_changed (mi_command_param_changed);
 147       observer_attach_memory_changed (mi_memory_changed);
 148
 149       /* The initial inferior is created before this function is
 150          called, so we need to report it explicitly.  Use iteration in
 151          case future version of GDB creates more than one inferior
 152          up-front.  */
 153       iterate_over_inferiors (report_initial_inferior, mi);
 154     }
 155
 156   return mi;
 157 }
 158
 159 static int
 160 mi_interpreter_resume (void *data)
 161 {
 162   struct mi_interp *mi = data;
 163
 164   /* As per hack note in mi_interpreter_init, swap in the output
 165      channels... */
 166   gdb_setup_readline ();
 167
 168   /* These overwrite some of the initialization done in
 169      _intialize_event_loop.  */
 170   call_readline = gdb_readline2;
 171   input_handler = mi_execute_command_input_handler;
 172   add_file_handler (input_fd, stdin_event_handler, 0);
 173   async_command_editing_p = 0;
 174   /* FIXME: This is a total hack for now.  PB's use of the MI
 175      implicitly relies on a bug in the async support which allows
 176      asynchronous commands to leak through the commmand loop.  The bug
 177      involves (but is not limited to) the fact that sync_execution was
 178      erroneously initialized to 0.  Duplicate by initializing it thus
 179      here...  */
 180   sync_execution = 0;
 181
 182   gdb_stdout = mi->out;
 183   /* Route error and log output through the MI.  */
 184   gdb_stderr = mi->err;
 185   gdb_stdlog = mi->log;
 186   /* Route target output through the MI.  */
 187   gdb_stdtarg = mi->targ;
 188   /* Route target error through the MI as well.  */
 189   gdb_stdtargerr = mi->targ;
 190
 191   /* Replace all the hooks that we know about.  There really needs to
 192      be a better way of doing this... */
 193   clear_interpreter_hooks ();
 194
 195   deprecated_show_load_progress = mi_load_progress;
 196
 197   /* If we're _the_ interpreter, take control.  */
 198   if (current_interp_named_p (INTERP_MI1))
 199     deprecated_command_loop_hook = mi1_command_loop;
 200   else if (current_interp_named_p (INTERP_MI2))
 201     deprecated_command_loop_hook = mi2_command_loop;
 202   else if (current_interp_named_p (INTERP_MI3))
 203     deprecated_command_loop_hook = mi3_command_loop;
 204   else
 205     deprecated_command_loop_hook = mi2_command_loop;
 206
 207   return 1;
 208 }
 209
 210 static int
 211 mi_interpreter_suspend (void *data)
 212 {
 213   gdb_disable_readline ();
 214   return 1;
 215 }
 216
 217 static struct gdb_exception
 218 mi_interpreter_exec (void *data, const char *command)
 219 {
 220   mi_execute_command_wrapper (command);
 221   return exception_none;
 222 }
 223
 224 /* Never display the default GDB prompt in MI case.  */
 225
 226 static int
 227 mi_interpreter_prompt_p (void *data)
 228 {
 229   return 0;
 230 }
 231
 232 void
 233 mi_cmd_interpreter_exec (char *command, char **argv, int argc)
 234 {
 235   struct interp *interp_to_use;
 236   int i;
 237   char *mi_error_message = NULL;
 238   struct cleanup *old_chain;
 239
 240   if (argc < 2)
 241     error (_("-interpreter-exec: "
 242              "Usage: -interpreter-exec interp command"));
 243
 244   interp_to_use = interp_lookup (argv[0]);
 245   if (interp_to_use == NULL)
 246     error (_("-interpreter-exec: could not find interpreter \"%s\""),
 247            argv[0]);
 248
 249   if (!interp_exec_p (interp_to_use))
 250     error (_("-interpreter-exec: interpreter \"%s\" "
 251              "does not support command execution"),
 252               argv[0]);
 253
 254   /* Insert the MI out hooks, making sure to also call the
 255      interpreter's hooks if it has any.  */
 256   /* KRS: We shouldn't need this... Events should be installed and
 257      they should just ALWAYS fire something out down the MI
 258      channel.  */
 259   mi_insert_notify_hooks ();
 260
 261   /* Now run the code.  */
 262
 263   old_chain = make_cleanup (null_cleanup, 0);
 264   for (i = 1; i < argc; i++)
 265     {
 266       struct gdb_exception e = interp_exec (interp_to_use, argv[i]);
 267
 268       if (e.reason < 0)
 269         {
 270           mi_error_message = xstrdup (e.message);
 271           make_cleanup (xfree, mi_error_message);
 272           break;
 273         }
 274     }
 275
 276   mi_remove_notify_hooks ();
 277
 278   if (mi_error_message != NULL)
 279     error ("%s", mi_error_message);
 280   do_cleanups (old_chain);
 281 }
 282
 283 /* This inserts a number of hooks that are meant to produce
 284    async-notify ("=") MI messages while running commands in another
 285    interpreter using mi_interpreter_exec.  The canonical use for this
 286    is to allow access to the gdb CLI interpreter from within the MI,
 287    while still producing MI style output when actions in the CLI
 288    command change GDB's state.  */
 289
 290 static void
 291 mi_insert_notify_hooks (void)
 292 {
 293   deprecated_query_hook = mi_interp_query_hook;
 294 }
 295
 296 static void
 297 mi_remove_notify_hooks (void)
 298 {
 299   deprecated_query_hook = NULL;
 300 }
 301
 302 static int
 303 mi_interp_query_hook (const char *ctlstr, va_list ap)
 304 {
 305   return 1;
 306 }
 307
 308 static void
 309 mi_execute_command_wrapper (const char *cmd)
 310 {
 311   mi_execute_command (cmd, stdin == instream);
 312 }
 313
 314 /* mi_execute_command_wrapper wrapper suitable for INPUT_HANDLER.  */
 315
 316 static void
 317 mi_execute_command_input_handler (char *cmd)
 318 {
 319   mi_execute_command_wrapper (cmd);
 320
 321   fputs_unfiltered ("(gdb) \n", raw_stdout);
 322   gdb_flush (raw_stdout);
 323 }
 324
 325 static void
 326 mi1_command_loop (void)
 327 {
 328   mi_command_loop (1);
 329 }
 330
 331 static void
 332 mi2_command_loop (void)
 333 {
 334   mi_command_loop (2);
 335 }
 336
 337 static void
 338 mi3_command_loop (void)
 339 {
 340   mi_command_loop (3);
 341 }
 342
 343 static void
 344 mi_command_loop (int mi_version)
 345 {
 346   /* Turn off 8 bit strings in quoted output.  Any character with the
 347      high bit set is printed using C's octal format.  */
 348   sevenbit_strings = 1;
 349
 350   /* Tell the world that we're alive.  */
 351   fputs_unfiltered ("(gdb) \n", raw_stdout);
 352   gdb_flush (raw_stdout);
 353
 354   start_event_loop ();
 355 }
 356
 357 static void
 358 mi_new_thread (struct thread_info *t)
 359 {
 360   struct mi_interp *mi = top_level_interpreter_data ();
 361   struct inferior *inf = find_inferior_pid (ptid_get_pid (t->ptid));
 362
 363   gdb_assert (inf);
 364
 365   fprintf_unfiltered (mi->event_channel,
 366                       "thread-created,id=\"%d\",group-id=\"i%d\"",
 367                       t->num, inf->num);
 368   gdb_flush (mi->event_channel);
 369 }
 370
 371 static void
 372 mi_thread_exit (struct thread_info *t, int silent)
 373 {
 374   struct mi_interp *mi;
 375   struct inferior *inf;
 376
 377   if (silent)
 378     return;
 379
 380   inf = find_inferior_pid (ptid_get_pid (t->ptid));
 381
 382   mi = top_level_interpreter_data ();
 383   target_terminal_ours ();
 384   fprintf_unfiltered (mi->event_channel,
 385                       "thread-exited,id=\"%d\",group-id=\"i%d\"",
 386                       t->num, inf->num);
 387   gdb_flush (mi->event_channel);
 388 }
 389
 390 /* Emit notification on changing the state of record.  */
 391
 392 static void
 393 mi_record_changed (struct inferior *inferior, int started)
 394 {
 395   struct mi_interp *mi = top_level_interpreter_data ();
 396
 397   fprintf_unfiltered (mi->event_channel,  "record-%s,thread-group=\"i%d\"",
 398                       started ? "started" : "stopped", inferior->num);
 399
 400   gdb_flush (mi->event_channel);
 401 }
 402
 403 static void
 404 mi_inferior_added (struct inferior *inf)
 405 {
 406   struct mi_interp *mi = top_level_interpreter_data ();
 407
 408   target_terminal_ours ();
 409   fprintf_unfiltered (mi->event_channel,
 410                       "thread-group-added,id=\"i%d\"",
 411                       inf->num);
 412   gdb_flush (mi->event_channel);
 413 }
 414
 415 static void
 416 mi_inferior_appeared (struct inferior *inf)
 417 {
 418   struct mi_interp *mi = top_level_interpreter_data ();
 419
 420   target_terminal_ours ();
 421   fprintf_unfiltered (mi->event_channel,
 422                       "thread-group-started,id=\"i%d\",pid=\"%d\"",
 423                       inf->num, inf->pid);
 424   gdb_flush (mi->event_channel);
 425 }
 426
 427 static void
 428 mi_inferior_exit (struct inferior *inf)
 429 {
 430   struct mi_interp *mi = top_level_interpreter_data ();
 431
 432   target_terminal_ours ();
 433   if (inf->has_exit_code)
 434     fprintf_unfiltered (mi->event_channel,
 435                         "thread-group-exited,id=\"i%d\",exit-code=\"%s\"",
 436                         inf->num, int_string (inf->exit_code, 8, 0, 0, 1));
 437   else
 438     fprintf_unfiltered (mi->event_channel,
 439                         "thread-group-exited,id=\"i%d\"", inf->num);
 440
 441   gdb_flush (mi->event_channel);
 442 }
 443
 444 static void
 445 mi_inferior_removed (struct inferior *inf)
 446 {
 447   struct mi_interp *mi = top_level_interpreter_data ();
 448
 449   target_terminal_ours ();
 450   fprintf_unfiltered (mi->event_channel,
 451                       "thread-group-removed,id=\"i%d\"",
 452                       inf->num);
 453   gdb_flush (mi->event_channel);
 454 }
 455
 456 static void
 457 mi_on_normal_stop (struct bpstats *bs, int print_frame)
 458 {
 459   /* Since this can be called when CLI command is executing,
 460      using cli interpreter, be sure to use MI uiout for output,
 461      not the current one.  */
 462   struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
 463
 464   if (print_frame)
 465     {
 466       int core;
 467
 468       if (current_uiout != mi_uiout)
 469         {
 470           /* The normal_stop function has printed frame information
 471              into CLI uiout, or some other non-MI uiout.  There's no
 472              way we can extract proper fields from random uiout
 473              object, so we print the frame again.  In practice, this
 474              can only happen when running a CLI command in MI.  */
 475           struct ui_out *saved_uiout = current_uiout;
 476           struct target_waitstatus last;
 477           ptid_t last_ptid;
 478
 479           current_uiout = mi_uiout;
 480
 481           get_last_target_status (&last_ptid, &last);
 482           bpstat_print (bs, last.kind);
 483
 484           print_stack_frame (get_selected_frame (NULL), 0, SRC_AND_LOC);
 485           current_uiout = saved_uiout;
 486         }
 487
 488       ui_out_field_int (mi_uiout, "thread-id",
 489                         pid_to_thread_id (inferior_ptid));
 490       if (non_stop)
 491         {
 492           struct cleanup *back_to = make_cleanup_ui_out_list_begin_end
 493             (mi_uiout, "stopped-threads");
 494
 495           ui_out_field_int (mi_uiout, NULL,
 496                             pid_to_thread_id (inferior_ptid));
 497           do_cleanups (back_to);
 498         }
 499       else
 500         ui_out_field_string (mi_uiout, "stopped-threads", "all");
 501
 502       core = target_core_of_thread (inferior_ptid);
 503       if (core != -1)
 504         ui_out_field_int (mi_uiout, "core", core);
 505     }
 506
 507   fputs_unfiltered ("*stopped", raw_stdout);
 508   mi_out_put (mi_uiout, raw_stdout);
 509   mi_out_rewind (mi_uiout);
 510   mi_print_timing_maybe ();
 511   fputs_unfiltered ("\n", raw_stdout);
 512   gdb_flush (raw_stdout);
 513 }
 514
 515 static void
 516 mi_about_to_proceed (void)
 517 {
 518   /* Suppress output while calling an inferior function.  */
 519
 520   if (!ptid_equal (inferior_ptid, null_ptid))
 521     {
 522       struct thread_info *tp = inferior_thread ();
 523
 524       if (tp->control.in_infcall)
 525         return;
 526     }
 527
 528   mi_proceeded = 1;
 529 }
 530
 531 /* When the element is non-zero, no MI notifications will be emitted in
 532    response to the corresponding observers.  */
 533
 534 struct mi_suppress_notification mi_suppress_notification =
 535   {
 536     0,
 537     0,
 538     0,
 539   };
 540
 541 /* Emit notification on changing a traceframe.  */
 542
 543 static void
 544 mi_traceframe_changed (int tfnum, int tpnum)
 545 {
 546   struct mi_interp *mi = top_level_interpreter_data ();
 547
 548   if (mi_suppress_notification.traceframe)
 549     return;
 550
 551   target_terminal_ours ();
 552
 553   if (tfnum >= 0)
 554     fprintf_unfiltered (mi->event_channel, "traceframe-changed,"
 555                         "num=\"%d\",tracepoint=\"%d\"\n",
 556                         tfnum, tpnum);
 557   else
 558     fprintf_unfiltered (mi->event_channel, "traceframe-changed,end");
 559
 560   gdb_flush (mi->event_channel);
 561 }
 562
 563 /* Emit notification on creating a trace state variable.  */
 564
 565 static void
 566 mi_tsv_created (const struct trace_state_variable *tsv)
 567 {
 568   struct mi_interp *mi = top_level_interpreter_data ();
 569
 570   target_terminal_ours ();
 571
 572   fprintf_unfiltered (mi->event_channel, "tsv-created,"
 573                       "name=\"%s\",initial=\"%s\"\n",
 574                       tsv->name, plongest (tsv->initial_value));
 575
 576   gdb_flush (mi->event_channel);
 577 }
 578
 579 /* Emit notification on deleting a trace state variable.  */
 580
 581 static void
 582 mi_tsv_deleted (const struct trace_state_variable *tsv)
 583 {
 584   struct mi_interp *mi = top_level_interpreter_data ();
 585
 586   target_terminal_ours ();
 587
 588   if (tsv != NULL)
 589     fprintf_unfiltered (mi->event_channel, "tsv-deleted,"
 590                         "name=\"%s\"\n", tsv->name);
 591   else
 592     fprintf_unfiltered (mi->event_channel, "tsv-deleted\n");
 593
 594   gdb_flush (mi->event_channel);
 595 }
 596
 597 /* Emit notification on modifying a trace state variable.  */
 598
 599 static void
 600 mi_tsv_modified (const struct trace_state_variable *tsv)
 601 {
 602   struct mi_interp *mi = top_level_interpreter_data ();
 603   struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
 604
 605   target_terminal_ours ();
 606
 607   fprintf_unfiltered (mi->event_channel,
 608                       "tsv-modified");
 609
 610   ui_out_redirect (mi_uiout, mi->event_channel);
 611
 612   ui_out_field_string (mi_uiout, "name", tsv->name);
 613   ui_out_field_string (mi_uiout, "initial",
 614                        plongest (tsv->initial_value));
 615   if (tsv->value_known)
 616     ui_out_field_string (mi_uiout, "current", plongest (tsv->value));
 617
 618   ui_out_redirect (mi_uiout, NULL);
 619
 620   gdb_flush (mi->event_channel);
 621 }
 622
 623 /* Emit notification about a created breakpoint.  */
 624
 625 static void
 626 mi_breakpoint_created (struct breakpoint *b)
 627 {
 628   struct mi_interp *mi = top_level_interpreter_data ();
 629   struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
 630   volatile struct gdb_exception e;
 631
 632   if (mi_suppress_notification.breakpoint)
 633     return;
 634
 635   if (b->number <= 0)
 636     return;
 637
 638   target_terminal_ours ();
 639   fprintf_unfiltered (mi->event_channel,
 640                       "breakpoint-created");
 641   /* We want the output from gdb_breakpoint_query to go to
 642      mi->event_channel.  One approach would be to just call
 643      gdb_breakpoint_query, and then use mi_out_put to send the current
 644      content of mi_outout into mi->event_channel.  However, that will
 645      break if anything is output to mi_uiout prior to calling the
 646      breakpoint_created notifications.  So, we use
 647      ui_out_redirect.  */
 648   ui_out_redirect (mi_uiout, mi->event_channel);
 649   TRY_CATCH (e, RETURN_MASK_ERROR)
 650     gdb_breakpoint_query (mi_uiout, b->number, NULL);
 651   ui_out_redirect (mi_uiout, NULL);
 652
 653   gdb_flush (mi->event_channel);
 654 }
 655
 656 /* Emit notification about deleted breakpoint.  */
 657
 658 static void
 659 mi_breakpoint_deleted (struct breakpoint *b)
 660 {
 661   struct mi_interp *mi = top_level_interpreter_data ();
 662
 663   if (mi_suppress_notification.breakpoint)
 664     return;
 665
 666   if (b->number <= 0)
 667     return;
 668
 669   target_terminal_ours ();
 670
 671   fprintf_unfiltered (mi->event_channel, "breakpoint-deleted,id=\"%d\"",
 672                       b->number);
 673
 674   gdb_flush (mi->event_channel);
 675 }
 676
 677 /* Emit notification about modified breakpoint.  */
 678
 679 static void
 680 mi_breakpoint_modified (struct breakpoint *b)
 681 {
 682   struct mi_interp *mi = top_level_interpreter_data ();
 683   struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
 684   volatile struct gdb_exception e;
 685
 686   if (mi_suppress_notification.breakpoint)
 687     return;
 688
 689   if (b->number <= 0)
 690     return;
 691
 692   target_terminal_ours ();
 693   fprintf_unfiltered (mi->event_channel,
 694                       "breakpoint-modified");
 695   /* We want the output from gdb_breakpoint_query to go to
 696      mi->event_channel.  One approach would be to just call
 697      gdb_breakpoint_query, and then use mi_out_put to send the current
 698      content of mi_outout into mi->event_channel.  However, that will
 699      break if anything is output to mi_uiout prior to calling the
 700      breakpoint_created notifications.  So, we use
 701      ui_out_redirect.  */
 702   ui_out_redirect (mi_uiout, mi->event_channel);
 703   TRY_CATCH (e, RETURN_MASK_ERROR)
 704     gdb_breakpoint_query (mi_uiout, b->number, NULL);
 705   ui_out_redirect (mi_uiout, NULL);
 706
 707   gdb_flush (mi->event_channel);
 708 }
 709
 710 static int
 711 mi_output_running_pid (struct thread_info *info, void *arg)
 712 {
 713   ptid_t *ptid = arg;
 714
 715   if (ptid_get_pid (*ptid) == ptid_get_pid (info->ptid))
 716     fprintf_unfiltered (raw_stdout,
 717                         "*running,thread-id=\"%d\"\n",
 718                         info->num);
 719
 720   return 0;
 721 }
 722
 723 static int
 724 mi_inferior_count (struct inferior *inf, void *arg)
 725 {
 726   if (inf->pid != 0)
 727     {
 728       int *count_p = arg;
 729       (*count_p)++;
 730     }
 731
 732   return 0;
 733 }
 734
 735 static void
 736 mi_on_resume (ptid_t ptid)
 737 {
 738   struct thread_info *tp = NULL;
 739
 740   if (ptid_equal (ptid, minus_one_ptid) || ptid_is_pid (ptid))
 741     tp = inferior_thread ();
 742   else
 743     tp = find_thread_ptid (ptid);
 744
 745   /* Suppress output while calling an inferior function.  */
 746   if (tp->control.in_infcall)
 747     return;
 748
 749   /* To cater for older frontends, emit ^running, but do it only once
 750      per each command.  We do it here, since at this point we know
 751      that the target was successfully resumed, and in non-async mode,
 752      we won't return back to MI interpreter code until the target
 753      is done running, so delaying the output of "^running" until then
 754      will make it impossible for frontend to know what's going on.
 755
 756      In future (MI3), we'll be outputting "^done" here.  */
 757   if (!running_result_record_printed && mi_proceeded)
 758     {
 759       fprintf_unfiltered (raw_stdout, "%s^running\n",
 760                           current_token ? current_token : "");
 761     }
 762
 763   if (PIDGET (ptid) == -1)
 764     fprintf_unfiltered (raw_stdout, "*running,thread-id=\"all\"\n");
 765   else if (ptid_is_pid (ptid))
 766     {
 767       int count = 0;
 768
 769       /* Backwards compatibility.  If there's only one inferior,
 770          output "all", otherwise, output each resumed thread
 771          individually.  */
 772       iterate_over_inferiors (mi_inferior_count, &count);
 773
 774       if (count == 1)
 775         fprintf_unfiltered (raw_stdout, "*running,thread-id=\"all\"\n");
 776       else
 777         iterate_over_threads (mi_output_running_pid, &ptid);
 778     }
 779   else
 780     {
 781       struct thread_info *ti = find_thread_ptid (ptid);
 782
 783       gdb_assert (ti);
 784       fprintf_unfiltered (raw_stdout, "*running,thread-id=\"%d\"\n", ti->num);
 785     }
 786
 787   if (!running_result_record_printed && mi_proceeded)
 788     {
 789       running_result_record_printed = 1;
 790       /* This is what gdb used to do historically -- printing prompt even if
 791          it cannot actually accept any input.  This will be surely removed
 792          for MI3, and may be removed even earler.  */
 793       /* FIXME: review the use of target_is_async_p here -- is that
 794          what we want? */
 795       if (!target_is_async_p ())
 796         fputs_unfiltered ("(gdb) \n", raw_stdout);
 797     }
 798   gdb_flush (raw_stdout);
 799 }
 800
 801 static void
 802 mi_solib_loaded (struct so_list *solib)
 803 {
 804   struct mi_interp *mi = top_level_interpreter_data ();
 805
 806   target_terminal_ours ();
 807   if (gdbarch_has_global_solist (target_gdbarch ()))
 808     fprintf_unfiltered (mi->event_channel,
 809                         "library-loaded,id=\"%s\",target-name=\"%s\","
 810                         "host-name=\"%s\",symbols-loaded=\"%d\"",
 811                         solib->so_original_name, solib->so_original_name,
 812                         solib->so_name, solib->symbols_loaded);
 813   else
 814     fprintf_unfiltered (mi->event_channel,
 815                         "library-loaded,id=\"%s\",target-name=\"%s\","
 816                         "host-name=\"%s\",symbols-loaded=\"%d\","
 817                         "thread-group=\"i%d\"",
 818                         solib->so_original_name, solib->so_original_name,
 819                         solib->so_name, solib->symbols_loaded,
 820                         current_inferior ()->num);
 821
 822   gdb_flush (mi->event_channel);
 823 }
 824
 825 static void
 826 mi_solib_unloaded (struct so_list *solib)
 827 {
 828   struct mi_interp *mi = top_level_interpreter_data ();
 829
 830   target_terminal_ours ();
 831   if (gdbarch_has_global_solist (target_gdbarch ()))
 832     fprintf_unfiltered (mi->event_channel,
 833                         "library-unloaded,id=\"%s\",target-name=\"%s\","
 834                         "host-name=\"%s\"",
 835                         solib->so_original_name, solib->so_original_name,
 836                         solib->so_name);
 837   else
 838     fprintf_unfiltered (mi->event_channel,
 839                         "library-unloaded,id=\"%s\",target-name=\"%s\","
 840                         "host-name=\"%s\",thread-group=\"i%d\"",
 841                         solib->so_original_name, solib->so_original_name,
 842                         solib->so_name, current_inferior ()->num);
 843
 844   gdb_flush (mi->event_channel);
 845 }
 846
 847 /* Emit notification about the command parameter change.  */
 848
 849 static void
 850 mi_command_param_changed (const char *param, const char *value)
 851 {
 852   struct mi_interp *mi = top_level_interpreter_data ();
 853   struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
 854
 855   if (mi_suppress_notification.cmd_param_changed)
 856     return;
 857
 858   target_terminal_ours ();
 859
 860   fprintf_unfiltered (mi->event_channel,
 861                       "cmd-param-changed");
 862
 863   ui_out_redirect (mi_uiout, mi->event_channel);
 864
 865   ui_out_field_string (mi_uiout, "param", param);
 866   ui_out_field_string (mi_uiout, "value", value);
 867
 868   ui_out_redirect (mi_uiout, NULL);
 869
 870   gdb_flush (mi->event_channel);
 871 }
 872
 873 /* Emit notification about the target memory change.  */
 874
 875 static void
 876 mi_memory_changed (struct inferior *inferior, CORE_ADDR memaddr,
 877                    ssize_t len, const bfd_byte *myaddr)
 878 {
 879   struct mi_interp *mi = top_level_interpreter_data ();
 880   struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
 881   struct obj_section *sec;
 882
 883   if (mi_suppress_notification.memory)
 884     return;
 885
 886   target_terminal_ours ();
 887
 888   fprintf_unfiltered (mi->event_channel,
 889                       "memory-changed");
 890
 891   ui_out_redirect (mi_uiout, mi->event_channel);
 892
 893   ui_out_field_fmt (mi_uiout, "thread-group", "i%d", inferior->num);
 894   ui_out_field_core_addr (mi_uiout, "addr", target_gdbarch (), memaddr);
 895   ui_out_field_fmt (mi_uiout, "len", "0x%zx", len);
 896
 897   /* Append 'type=code' into notification if MEMADDR falls in the range of
 898      sections contain code.  */
 899   sec = find_pc_section (memaddr);
 900   if (sec != NULL && sec->objfile != NULL)
 901     {
 902       flagword flags = bfd_get_section_flags (sec->objfile->obfd,
 903                                               sec->the_bfd_section);
 904
 905       if (flags & SEC_CODE)
 906         ui_out_field_string (mi_uiout, "type", "code");
 907     }
 908
 909   ui_out_redirect (mi_uiout, NULL);
 910
 911   gdb_flush (mi->event_channel);
 912 }
 913
 914 static int
 915 report_initial_inferior (struct inferior *inf, void *closure)
 916 {
 917   /* This function is called from mi_intepreter_init, and since
 918      mi_inferior_added assumes that inferior is fully initialized
 919      and top_level_interpreter_data is set, we cannot call
 920      it here.  */
 921   struct mi_interp *mi = closure;
 922
 923   target_terminal_ours ();
 924   fprintf_unfiltered (mi->event_channel,
 925                       "thread-group-added,id=\"i%d\"",
 926                       inf->num);
 927   gdb_flush (mi->event_channel);
 928   return 0;
 929 }
 930
 931 static struct ui_out *
 932 mi_ui_out (struct interp *interp)
 933 {
 934   struct mi_interp *mi = interp_data (interp);
 935
 936   return mi->uiout;
 937 }
 938
 939 /* Save the original value of raw_stdout here when logging, so we can
 940    restore correctly when done.  */
 941
 942 static struct ui_file *saved_raw_stdout;
 943
 944 /* Do MI-specific logging actions; save raw_stdout, and change all
 945    the consoles to use the supplied ui-file(s).  */
 946
 947 static int
 948 mi_set_logging (struct interp *interp, int start_log,
 949                 struct ui_file *out, struct ui_file *logfile)
 950 {
 951   struct mi_interp *mi = interp_data (interp);
 952
 953   if (!mi)
 954     return 0;
 955
 956   if (start_log)
 957     {
 958       /* The tee created already is based on gdb_stdout, which for MI
 959          is a console and so we end up in an infinite loop of console
 960          writing to ui_file writing to console etc.  So discard the
 961          existing tee (it hasn't been used yet, and MI won't ever use
 962          it), and create one based on raw_stdout instead.  */
 963       if (logfile)
 964         {
 965           ui_file_delete (out);
 966           out = tee_file_new (raw_stdout, 0, logfile, 0);
 967         }
 968
 969       saved_raw_stdout = raw_stdout;
 970       raw_stdout = out;
 971     }
 972   else
 973     {
 974       raw_stdout = saved_raw_stdout;
 975       saved_raw_stdout = NULL;
 976     }
 977
 978   mi_console_set_raw (mi->out, raw_stdout);
 979   mi_console_set_raw (mi->err, raw_stdout);
 980   mi_console_set_raw (mi->log, raw_stdout);
 981   mi_console_set_raw (mi->targ, raw_stdout);
 982   mi_console_set_raw (mi->event_channel, raw_stdout);
 983
 984   return 1;
 985 }
 986
 987 extern initialize_file_ftype _initialize_mi_interp; /* -Wmissing-prototypes */
 988
 989 void
 990 _initialize_mi_interp (void)
 991 {
 992   static const struct interp_procs procs =
 993     {
 994       mi_interpreter_init,      /* init_proc */
 995       mi_interpreter_resume,    /* resume_proc */
 996       mi_interpreter_suspend,   /* suspend_proc */
 997       mi_interpreter_exec,      /* exec_proc */
 998       mi_interpreter_prompt_p,  /* prompt_proc_p */
 999       mi_ui_out,                /* ui_out_proc */
1000       mi_set_logging            /* set_logging_proc */
1001     };
1002
1003   /* The various interpreter levels.  */
1004   interp_add (interp_new (INTERP_MI1, &procs));
1005   interp_add (interp_new (INTERP_MI2, &procs));
1006   interp_add (interp_new (INTERP_MI3, &procs));
1007   interp_add (interp_new (INTERP_MI, &procs));
1008 }