gdb/mi/mi-interp.c

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