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