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