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