gdb/mi/mi-interp.c

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