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