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