gdb/mi/mi-interp.c

   1 /* MI Interpreter Definitions and Commands for GDB, the GNU debugger.
   2
   3    Copyright (C) 2002-2016 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 "interps.h"
  22 #include "event-top.h"
  23 #include "event-loop.h"
  24 #include "inferior.h"
  25 #include "infrun.h"
  26 #include "ui-out.h"
  27 #include "top.h"
  28 #include "mi-main.h"
  29 #include "mi-cmds.h"
  30 #include "mi-out.h"
  31 #include "mi-console.h"
  32 #include "mi-common.h"
  33 #include "observer.h"
  34 #include "gdbthread.h"
  35 #include "solist.h"
  36 #include "gdb.h"
  37 #include "objfiles.h"
  38 #include "tracepoint.h"
  39 #include "cli-out.h"
  40 #include "thread-fsm.h"
  41
  42 /* These are the interpreter setup, etc. functions for the MI
  43    interpreter.  */
  44
  45 static void mi_execute_command_wrapper (const char *cmd);
  46 static void mi_execute_command_input_handler (char *cmd);
  47 static void mi_command_loop (void *data);
  48
  49 /* These are hooks that we put in place while doing interpreter_exec
  50    so we can report interesting things that happened "behind the MI's
  51    back" in this command.  */
  52
  53 static int mi_interp_query_hook (const char *ctlstr, va_list ap)
  54   ATTRIBUTE_PRINTF (1, 0);
  55
  56 static void mi_insert_notify_hooks (void);
  57 static void mi_remove_notify_hooks (void);
  58
  59 static void mi_on_signal_received (enum gdb_signal siggnal);
  60 static void mi_on_end_stepping_range (void);
  61 static void mi_on_signal_exited (enum gdb_signal siggnal);
  62 static void mi_on_exited (int exitstatus);
  63 static void mi_on_normal_stop (struct bpstats *bs, int print_frame);
  64 static void mi_on_no_history (void);
  65
  66 static void mi_new_thread (struct thread_info *t);
  67 static void mi_thread_exit (struct thread_info *t, int silent);
  68 static void mi_record_changed (struct inferior*, int);
  69 static void mi_inferior_added (struct inferior *inf);
  70 static void mi_inferior_appeared (struct inferior *inf);
  71 static void mi_inferior_exit (struct inferior *inf);
  72 static void mi_inferior_removed (struct inferior *inf);
  73 static void mi_on_resume (ptid_t ptid);
  74 static void mi_solib_loaded (struct so_list *solib);
  75 static void mi_solib_unloaded (struct so_list *solib);
  76 static void mi_about_to_proceed (void);
  77 static void mi_traceframe_changed (int tfnum, int tpnum);
  78 static void mi_tsv_created (const struct trace_state_variable *tsv);
  79 static void mi_tsv_deleted (const struct trace_state_variable *tsv);
  80 static void mi_tsv_modified (const struct trace_state_variable *tsv);
  81 static void mi_breakpoint_created (struct breakpoint *b);
  82 static void mi_breakpoint_deleted (struct breakpoint *b);
  83 static void mi_breakpoint_modified (struct breakpoint *b);
  84 static void mi_command_param_changed (const char *param, const char *value);
  85 static void mi_memory_changed (struct inferior *inf, CORE_ADDR memaddr,
  86                                ssize_t len, const bfd_byte *myaddr);
  87 static void mi_on_sync_execution_done (void);
  88
  89 static int report_initial_inferior (struct inferior *inf, void *closure);
  90
  91 static void *
  92 mi_interpreter_init (struct interp *interp, int top_level)
  93 {
  94   struct mi_interp *mi = XNEW (struct mi_interp);
  95   const char *name;
  96   int mi_version;
  97
  98   /* Assign the output channel created at startup to its own global,
  99      so that we can create a console channel that encapsulates and
 100      prefixes all gdb_output-type bits coming from the rest of the
 101      debugger.  */
 102
 103   raw_stdout = gdb_stdout;
 104
 105   /* Create MI console channels, each with a different prefix so they
 106      can be distinguished.  */
 107   mi->out = mi_console_file_new (raw_stdout, "~", '"');
 108   mi->err = mi_console_file_new (raw_stdout, "&", '"');
 109   mi->log = mi->err;
 110   mi->targ = mi_console_file_new (raw_stdout, "@", '"');
 111   mi->event_channel = mi_console_file_new (raw_stdout, "=", 0);
 112
 113   name = interp_name (interp);
 114   /* INTERP_MI selects the most recent released version.  "mi2" was
 115      released as part of GDB 6.0.  */
 116   if (strcmp (name, INTERP_MI) == 0)
 117     mi_version = 2;
 118   else if (strcmp (name, INTERP_MI1) == 0)
 119     mi_version = 1;
 120   else if (strcmp (name, INTERP_MI2) == 0)
 121     mi_version = 2;
 122   else if (strcmp (name, INTERP_MI3) == 0)
 123     mi_version = 3;
 124   else
 125     gdb_assert_not_reached ("unhandled MI version");
 126
 127   mi->mi_uiout = mi_out_new (mi_version);
 128   mi->cli_uiout = cli_out_new (mi->out);
 129
 130   /* There are installed even if MI is not the top level interpreter.
 131      The callbacks themselves decide whether to be skipped.  */
 132   observer_attach_signal_received (mi_on_signal_received);
 133   observer_attach_end_stepping_range (mi_on_end_stepping_range);
 134   observer_attach_signal_exited (mi_on_signal_exited);
 135   observer_attach_exited (mi_on_exited);
 136   observer_attach_no_history (mi_on_no_history);
 137
 138   if (top_level)
 139     {
 140       observer_attach_new_thread (mi_new_thread);
 141       observer_attach_thread_exit (mi_thread_exit);
 142       observer_attach_inferior_added (mi_inferior_added);
 143       observer_attach_inferior_appeared (mi_inferior_appeared);
 144       observer_attach_inferior_exit (mi_inferior_exit);
 145       observer_attach_inferior_removed (mi_inferior_removed);
 146       observer_attach_record_changed (mi_record_changed);
 147       observer_attach_normal_stop (mi_on_normal_stop);
 148       observer_attach_target_resumed (mi_on_resume);
 149       observer_attach_solib_loaded (mi_solib_loaded);
 150       observer_attach_solib_unloaded (mi_solib_unloaded);
 151       observer_attach_about_to_proceed (mi_about_to_proceed);
 152       observer_attach_traceframe_changed (mi_traceframe_changed);
 153       observer_attach_tsv_created (mi_tsv_created);
 154       observer_attach_tsv_deleted (mi_tsv_deleted);
 155       observer_attach_tsv_modified (mi_tsv_modified);
 156       observer_attach_breakpoint_created (mi_breakpoint_created);
 157       observer_attach_breakpoint_deleted (mi_breakpoint_deleted);
 158       observer_attach_breakpoint_modified (mi_breakpoint_modified);
 159       observer_attach_command_param_changed (mi_command_param_changed);
 160       observer_attach_memory_changed (mi_memory_changed);
 161       observer_attach_sync_execution_done (mi_on_sync_execution_done);
 162
 163       /* The initial inferior is created before this function is
 164          called, so we need to report it explicitly.  Use iteration in
 165          case future version of GDB creates more than one inferior
 166          up-front.  */
 167       iterate_over_inferiors (report_initial_inferior, mi);
 168     }
 169
 170   return mi;
 171 }
 172
 173 static int
 174 mi_interpreter_resume (void *data)
 175 {
 176   struct mi_interp *mi = (struct mi_interp *) data;
 177
 178   /* As per hack note in mi_interpreter_init, swap in the output
 179      channels... */
 180   gdb_setup_readline ();
 181
 182   /* These overwrite some of the initialization done in
 183      _intialize_event_loop.  */
 184   call_readline = gdb_readline_no_editing_callback;
 185   input_handler = mi_execute_command_input_handler;
 186   async_command_editing_p = 0;
 187   /* FIXME: This is a total hack for now.  PB's use of the MI
 188      implicitly relies on a bug in the async support which allows
 189      asynchronous commands to leak through the commmand loop.  The bug
 190      involves (but is not limited to) the fact that sync_execution was
 191      erroneously initialized to 0.  Duplicate by initializing it thus
 192      here...  */
 193   sync_execution = 0;
 194
 195   gdb_stdout = mi->out;
 196   /* Route error and log output through the MI.  */
 197   gdb_stderr = mi->err;
 198   gdb_stdlog = mi->log;
 199   /* Route target output through the MI.  */
 200   gdb_stdtarg = mi->targ;
 201   /* Route target error through the MI as well.  */
 202   gdb_stdtargerr = mi->targ;
 203
 204   /* Replace all the hooks that we know about.  There really needs to
 205      be a better way of doing this... */
 206   clear_interpreter_hooks ();
 207
 208   deprecated_show_load_progress = mi_load_progress;
 209
 210   return 1;
 211 }
 212
 213 static int
 214 mi_interpreter_suspend (void *data)
 215 {
 216   gdb_disable_readline ();
 217   return 1;
 218 }
 219
 220 static struct gdb_exception
 221 mi_interpreter_exec (void *data, const char *command)
 222 {
 223   mi_execute_command_wrapper (command);
 224   return exception_none;
 225 }
 226
 227 void
 228 mi_cmd_interpreter_exec (char *command, char **argv, int argc)
 229 {
 230   struct interp *interp_to_use;
 231   int i;
 232   char *mi_error_message = NULL;
 233   struct cleanup *old_chain;
 234
 235   if (argc < 2)
 236     error (_("-interpreter-exec: "
 237              "Usage: -interpreter-exec interp command"));
 238
 239   interp_to_use = interp_lookup (argv[0]);
 240   if (interp_to_use == NULL)
 241     error (_("-interpreter-exec: could not find interpreter \"%s\""),
 242            argv[0]);
 243
 244   /* Note that unlike the CLI version of this command, we don't
 245      actually set INTERP_TO_USE as the current interpreter, as we
 246      still want gdb_stdout, etc. to point at MI streams.  */
 247
 248   /* Insert the MI out hooks, making sure to also call the
 249      interpreter's hooks if it has any.  */
 250   /* KRS: We shouldn't need this... Events should be installed and
 251      they should just ALWAYS fire something out down the MI
 252      channel.  */
 253   mi_insert_notify_hooks ();
 254
 255   /* Now run the code.  */
 256
 257   old_chain = make_cleanup (null_cleanup, 0);
 258   for (i = 1; i < argc; i++)
 259     {
 260       struct gdb_exception e = interp_exec (interp_to_use, argv[i]);
 261
 262       if (e.reason < 0)
 263         {
 264           mi_error_message = xstrdup (e.message);
 265           make_cleanup (xfree, mi_error_message);
 266           break;
 267         }
 268     }
 269
 270   mi_remove_notify_hooks ();
 271
 272   if (mi_error_message != NULL)
 273     error ("%s", mi_error_message);
 274   do_cleanups (old_chain);
 275 }
 276
 277 /* This inserts a number of hooks that are meant to produce
 278    async-notify ("=") MI messages while running commands in another
 279    interpreter using mi_interpreter_exec.  The canonical use for this
 280    is to allow access to the gdb CLI interpreter from within the MI,
 281    while still producing MI style output when actions in the CLI
 282    command change GDB's state.  */
 283
 284 static void
 285 mi_insert_notify_hooks (void)
 286 {
 287   deprecated_query_hook = mi_interp_query_hook;
 288 }
 289
 290 static void
 291 mi_remove_notify_hooks (void)
 292 {
 293   deprecated_query_hook = NULL;
 294 }
 295
 296 static int
 297 mi_interp_query_hook (const char *ctlstr, va_list ap)
 298 {
 299   return 1;
 300 }
 301
 302 static void
 303 mi_execute_command_wrapper (const char *cmd)
 304 {
 305   mi_execute_command (cmd, stdin == instream);
 306 }
 307
 308 /* Observer for the synchronous_command_done notification.  */
 309
 310 static void
 311 mi_on_sync_execution_done (void)
 312 {
 313   /* If MI is sync, then output the MI prompt now, indicating we're
 314      ready for further input.  */
 315   if (!mi_async_p ())
 316     {
 317       fputs_unfiltered ("(gdb) \n", raw_stdout);
 318       gdb_flush (raw_stdout);
 319     }
 320 }
 321
 322 /* mi_execute_command_wrapper wrapper suitable for INPUT_HANDLER.  */
 323
 324 static void
 325 mi_execute_command_input_handler (char *cmd)
 326 {
 327   mi_execute_command_wrapper (cmd);
 328
 329   /* Print a prompt, indicating we're ready for further input, unless
 330      we just started a synchronous command.  In that case, we're about
 331      to go back to the event loop and will output the prompt in the
 332      'synchronous_command_done' observer when the target next
 333      stops.  */
 334   if (!sync_execution)
 335     {
 336       fputs_unfiltered ("(gdb) \n", raw_stdout);
 337       gdb_flush (raw_stdout);
 338     }
 339 }
 340
 341 static void
 342 mi_command_loop (void *data)
 343 {
 344   /* Turn off 8 bit strings in quoted output.  Any character with the
 345      high bit set is printed using C's octal format.  */
 346   sevenbit_strings = 1;
 347
 348   /* Tell the world that we're alive.  */
 349   fputs_unfiltered ("(gdb) \n", raw_stdout);
 350   gdb_flush (raw_stdout);
 351
 352   start_event_loop ();
 353 }
 354
 355 static void
 356 mi_new_thread (struct thread_info *t)
 357 {
 358   struct mi_interp *mi = (struct mi_interp *) top_level_interpreter_data ();
 359   struct inferior *inf = find_inferior_ptid (t->ptid);
 360   struct cleanup *old_chain;
 361
 362   gdb_assert (inf);
 363
 364   old_chain = make_cleanup_restore_target_terminal ();
 365   target_terminal_ours_for_output ();
 366
 367   fprintf_unfiltered (mi->event_channel,
 368                       "thread-created,id=\"%d\",group-id=\"i%d\"",
 369                       t->global_num, inf->num);
 370   gdb_flush (mi->event_channel);
 371
 372   do_cleanups (old_chain);
 373 }
 374
 375 static void
 376 mi_thread_exit (struct thread_info *t, int silent)
 377 {
 378   struct mi_interp *mi;
 379   struct inferior *inf;
 380   struct cleanup *old_chain;
 381
 382   if (silent)
 383     return;
 384
 385   inf = find_inferior_ptid (t->ptid);
 386
 387   mi = (struct mi_interp *) top_level_interpreter_data ();
 388   old_chain = make_cleanup_restore_target_terminal ();
 389   target_terminal_ours_for_output ();
 390
 391   fprintf_unfiltered (mi->event_channel,
 392                       "thread-exited,id=\"%d\",group-id=\"i%d\"",
 393                       t->global_num, inf->num);
 394   gdb_flush (mi->event_channel);
 395
 396   do_cleanups (old_chain);
 397 }
 398
 399 /* Emit notification on changing the state of record.  */
 400
 401 static void
 402 mi_record_changed (struct inferior *inferior, int started)
 403 {
 404   struct mi_interp *mi = (struct mi_interp *) top_level_interpreter_data ();
 405   struct cleanup *old_chain;
 406
 407   old_chain = make_cleanup_restore_target_terminal ();
 408   target_terminal_ours_for_output ();
 409
 410   fprintf_unfiltered (mi->event_channel,  "record-%s,thread-group=\"i%d\"",
 411                       started ? "started" : "stopped", inferior->num);
 412
 413   gdb_flush (mi->event_channel);
 414
 415   do_cleanups (old_chain);
 416 }
 417
 418 static void
 419 mi_inferior_added (struct inferior *inf)
 420 {
 421   struct mi_interp *mi = (struct mi_interp *) top_level_interpreter_data ();
 422   struct cleanup *old_chain;
 423
 424   old_chain = make_cleanup_restore_target_terminal ();
 425   target_terminal_ours_for_output ();
 426
 427   fprintf_unfiltered (mi->event_channel,
 428                       "thread-group-added,id=\"i%d\"",
 429                       inf->num);
 430   gdb_flush (mi->event_channel);
 431
 432   do_cleanups (old_chain);
 433 }
 434
 435 static void
 436 mi_inferior_appeared (struct inferior *inf)
 437 {
 438   struct mi_interp *mi = (struct mi_interp *) top_level_interpreter_data ();
 439   struct cleanup *old_chain;
 440
 441   old_chain = make_cleanup_restore_target_terminal ();
 442   target_terminal_ours_for_output ();
 443
 444   fprintf_unfiltered (mi->event_channel,
 445                       "thread-group-started,id=\"i%d\",pid=\"%d\"",
 446                       inf->num, inf->pid);
 447   gdb_flush (mi->event_channel);
 448
 449   do_cleanups (old_chain);
 450 }
 451
 452 static void
 453 mi_inferior_exit (struct inferior *inf)
 454 {
 455   struct mi_interp *mi = (struct mi_interp *) top_level_interpreter_data ();
 456   struct cleanup *old_chain;
 457
 458   old_chain = make_cleanup_restore_target_terminal ();
 459   target_terminal_ours_for_output ();
 460
 461   if (inf->has_exit_code)
 462     fprintf_unfiltered (mi->event_channel,
 463                         "thread-group-exited,id=\"i%d\",exit-code=\"%s\"",
 464                         inf->num, int_string (inf->exit_code, 8, 0, 0, 1));
 465   else
 466     fprintf_unfiltered (mi->event_channel,
 467                         "thread-group-exited,id=\"i%d\"", inf->num);
 468   gdb_flush (mi->event_channel);
 469
 470   do_cleanups (old_chain);
 471 }
 472
 473 static void
 474 mi_inferior_removed (struct inferior *inf)
 475 {
 476   struct mi_interp *mi = (struct mi_interp *) top_level_interpreter_data ();
 477   struct cleanup *old_chain;
 478
 479   old_chain = make_cleanup_restore_target_terminal ();
 480   target_terminal_ours_for_output ();
 481
 482   fprintf_unfiltered (mi->event_channel,
 483                       "thread-group-removed,id=\"i%d\"",
 484                       inf->num);
 485   gdb_flush (mi->event_channel);
 486
 487   do_cleanups (old_chain);
 488 }
 489
 490 /* Return the MI interpreter, if it is active -- either because it's
 491    the top-level interpreter or the interpreter executing the current
 492    command.  Returns NULL if the MI interpreter is not being used.  */
 493
 494 static struct interp *
 495 find_mi_interpreter (void)
 496 {
 497   struct interp *interp;
 498
 499   interp = top_level_interpreter ();
 500   if (ui_out_is_mi_like_p (interp_ui_out (interp)))
 501     return interp;
 502
 503   interp = command_interp ();
 504   if (ui_out_is_mi_like_p (interp_ui_out (interp)))
 505     return interp;
 506
 507   return NULL;
 508 }
 509
 510 /* Return the MI_INTERP structure of the active MI interpreter.
 511    Returns NULL if MI is not active.  */
 512
 513 static struct mi_interp *
 514 mi_interp_data (void)
 515 {
 516   struct interp *interp = find_mi_interpreter ();
 517
 518   if (interp != NULL)
 519     return (struct mi_interp *) interp_data (interp);
 520   return NULL;
 521 }
 522
 523 /* Observers for several run control events that print why the
 524    inferior has stopped to both the the MI event channel and to the MI
 525    console.  If the MI interpreter is not active, print nothing.  */
 526
 527 /* Observer for the signal_received notification.  */
 528
 529 static void
 530 mi_on_signal_received (enum gdb_signal siggnal)
 531 {
 532   struct mi_interp *mi = mi_interp_data ();
 533
 534   if (mi == NULL)
 535     return;
 536
 537   print_signal_received_reason (mi->mi_uiout, siggnal);
 538   print_signal_received_reason (mi->cli_uiout, siggnal);
 539 }
 540
 541 /* Observer for the end_stepping_range notification.  */
 542
 543 static void
 544 mi_on_end_stepping_range (void)
 545 {
 546   struct mi_interp *mi = mi_interp_data ();
 547
 548   if (mi == NULL)
 549     return;
 550
 551   print_end_stepping_range_reason (mi->mi_uiout);
 552   print_end_stepping_range_reason (mi->cli_uiout);
 553 }
 554
 555 /* Observer for the signal_exited notification.  */
 556
 557 static void
 558 mi_on_signal_exited (enum gdb_signal siggnal)
 559 {
 560   struct mi_interp *mi = mi_interp_data ();
 561
 562   if (mi == NULL)
 563     return;
 564
 565   print_signal_exited_reason (mi->mi_uiout, siggnal);
 566   print_signal_exited_reason (mi->cli_uiout, siggnal);
 567 }
 568
 569 /* Observer for the exited notification.  */
 570
 571 static void
 572 mi_on_exited (int exitstatus)
 573 {
 574   struct mi_interp *mi = mi_interp_data ();
 575
 576   if (mi == NULL)
 577     return;
 578
 579   print_exited_reason (mi->mi_uiout, exitstatus);
 580   print_exited_reason (mi->cli_uiout, exitstatus);
 581 }
 582
 583 /* Observer for the no_history notification.  */
 584
 585 static void
 586 mi_on_no_history (void)
 587 {
 588   struct mi_interp *mi = mi_interp_data ();
 589
 590   if (mi == NULL)
 591     return;
 592
 593   print_no_history_reason (mi->mi_uiout);
 594   print_no_history_reason (mi->cli_uiout);
 595 }
 596
 597 static void
 598 mi_on_normal_stop (struct bpstats *bs, int print_frame)
 599 {
 600   /* Since this can be called when CLI command is executing,
 601      using cli interpreter, be sure to use MI uiout for output,
 602      not the current one.  */
 603   struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
 604
 605   if (print_frame)
 606     {
 607       struct thread_info *tp;
 608       int core;
 609
 610       tp = inferior_thread ();
 611
 612       if (tp->thread_fsm != NULL
 613           && thread_fsm_finished_p (tp->thread_fsm))
 614         {
 615           enum async_reply_reason reason;
 616
 617           reason = thread_fsm_async_reply_reason (tp->thread_fsm);
 618           ui_out_field_string (mi_uiout, "reason",
 619                                async_reason_lookup (reason));
 620         }
 621       print_stop_event (mi_uiout);
 622
 623       /* Breakpoint hits should always be mirrored to the console.
 624          Deciding what to mirror to the console wrt to breakpoints and
 625          random stops gets messy real fast.  E.g., say "s" trips on a
 626          breakpoint.  We'd clearly want to mirror the event to the
 627          console in this case.  But what about more complicated cases
 628          like "s&; thread n; s&", and one of those steps spawning a
 629          new thread, and that thread hitting a breakpoint?  It's
 630          impossible in general to track whether the thread had any
 631          relation to the commands that had been executed.  So we just
 632          simplify and always mirror breakpoints and random events to
 633          the console.
 634
 635          OTOH, we should print the source line to the console when
 636          stepping or other similar commands, iff the step was started
 637          by a console command, but not if it was started with
 638          -exec-step or similar.  */
 639       if ((bpstat_what (tp->control.stop_bpstat).main_action
 640            == BPSTAT_WHAT_STOP_NOISY)
 641           || !(tp->thread_fsm != NULL
 642                && thread_fsm_finished_p (tp->thread_fsm))
 643           || (tp->control.command_interp != NULL
 644               && tp->control.command_interp != top_level_interpreter ()))
 645         {
 646           struct mi_interp *mi
 647             = (struct mi_interp *) top_level_interpreter_data ();
 648
 649           print_stop_event (mi->cli_uiout);
 650         }
 651
 652       tp = inferior_thread ();
 653       ui_out_field_int (mi_uiout, "thread-id", tp->global_num);
 654       if (non_stop)
 655         {
 656           struct cleanup *back_to = make_cleanup_ui_out_list_begin_end
 657             (mi_uiout, "stopped-threads");
 658
 659           ui_out_field_int (mi_uiout, NULL, tp->global_num);
 660           do_cleanups (back_to);
 661         }
 662       else
 663         ui_out_field_string (mi_uiout, "stopped-threads", "all");
 664
 665       core = target_core_of_thread (inferior_ptid);
 666       if (core != -1)
 667         ui_out_field_int (mi_uiout, "core", core);
 668     }
 669
 670   fputs_unfiltered ("*stopped", raw_stdout);
 671   mi_out_put (mi_uiout, raw_stdout);
 672   mi_out_rewind (mi_uiout);
 673   mi_print_timing_maybe ();
 674   fputs_unfiltered ("\n", raw_stdout);
 675   gdb_flush (raw_stdout);
 676 }
 677
 678 static void
 679 mi_about_to_proceed (void)
 680 {
 681   /* Suppress output while calling an inferior function.  */
 682
 683   if (!ptid_equal (inferior_ptid, null_ptid))
 684     {
 685       struct thread_info *tp = inferior_thread ();
 686
 687       if (tp->control.in_infcall)
 688         return;
 689     }
 690
 691   mi_proceeded = 1;
 692 }
 693
 694 /* When the element is non-zero, no MI notifications will be emitted in
 695    response to the corresponding observers.  */
 696
 697 struct mi_suppress_notification mi_suppress_notification =
 698   {
 699     0,
 700     0,
 701     0,
 702   };
 703
 704 /* Emit notification on changing a traceframe.  */
 705
 706 static void
 707 mi_traceframe_changed (int tfnum, int tpnum)
 708 {
 709   struct mi_interp *mi = (struct mi_interp *) top_level_interpreter_data ();
 710   struct cleanup *old_chain;
 711
 712   if (mi_suppress_notification.traceframe)
 713     return;
 714
 715   old_chain = make_cleanup_restore_target_terminal ();
 716   target_terminal_ours_for_output ();
 717
 718   if (tfnum >= 0)
 719     fprintf_unfiltered (mi->event_channel, "traceframe-changed,"
 720                         "num=\"%d\",tracepoint=\"%d\"\n",
 721                         tfnum, tpnum);
 722   else
 723     fprintf_unfiltered (mi->event_channel, "traceframe-changed,end");
 724
 725   gdb_flush (mi->event_channel);
 726
 727   do_cleanups (old_chain);
 728 }
 729
 730 /* Emit notification on creating a trace state variable.  */
 731
 732 static void
 733 mi_tsv_created (const struct trace_state_variable *tsv)
 734 {
 735   struct mi_interp *mi = (struct mi_interp *) top_level_interpreter_data ();
 736   struct cleanup *old_chain;
 737
 738   old_chain = make_cleanup_restore_target_terminal ();
 739   target_terminal_ours_for_output ();
 740
 741   fprintf_unfiltered (mi->event_channel, "tsv-created,"
 742                       "name=\"%s\",initial=\"%s\"\n",
 743                       tsv->name, plongest (tsv->initial_value));
 744
 745   gdb_flush (mi->event_channel);
 746
 747   do_cleanups (old_chain);
 748 }
 749
 750 /* Emit notification on deleting a trace state variable.  */
 751
 752 static void
 753 mi_tsv_deleted (const struct trace_state_variable *tsv)
 754 {
 755   struct mi_interp *mi = (struct mi_interp *) top_level_interpreter_data ();
 756   struct cleanup *old_chain;
 757
 758   old_chain = make_cleanup_restore_target_terminal ();
 759   target_terminal_ours_for_output ();
 760
 761   if (tsv != NULL)
 762     fprintf_unfiltered (mi->event_channel, "tsv-deleted,"
 763                         "name=\"%s\"\n", tsv->name);
 764   else
 765     fprintf_unfiltered (mi->event_channel, "tsv-deleted\n");
 766
 767   gdb_flush (mi->event_channel);
 768
 769   do_cleanups (old_chain);
 770 }
 771
 772 /* Emit notification on modifying a trace state variable.  */
 773
 774 static void
 775 mi_tsv_modified (const struct trace_state_variable *tsv)
 776 {
 777   struct mi_interp *mi = (struct mi_interp *) top_level_interpreter_data ();
 778   struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
 779   struct cleanup *old_chain;
 780
 781   old_chain = make_cleanup_restore_target_terminal ();
 782   target_terminal_ours_for_output ();
 783
 784   fprintf_unfiltered (mi->event_channel,
 785                       "tsv-modified");
 786
 787   ui_out_redirect (mi_uiout, mi->event_channel);
 788
 789   ui_out_field_string (mi_uiout, "name", tsv->name);
 790   ui_out_field_string (mi_uiout, "initial",
 791                        plongest (tsv->initial_value));
 792   if (tsv->value_known)
 793     ui_out_field_string (mi_uiout, "current", plongest (tsv->value));
 794
 795   ui_out_redirect (mi_uiout, NULL);
 796
 797   gdb_flush (mi->event_channel);
 798
 799   do_cleanups (old_chain);
 800 }
 801
 802 /* Emit notification about a created breakpoint.  */
 803
 804 static void
 805 mi_breakpoint_created (struct breakpoint *b)
 806 {
 807   struct mi_interp *mi = (struct mi_interp *) top_level_interpreter_data ();
 808   struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
 809   struct cleanup *old_chain;
 810
 811   if (mi_suppress_notification.breakpoint)
 812     return;
 813
 814   if (b->number <= 0)
 815     return;
 816
 817   old_chain = make_cleanup_restore_target_terminal ();
 818   target_terminal_ours_for_output ();
 819
 820   fprintf_unfiltered (mi->event_channel,
 821                       "breakpoint-created");
 822   /* We want the output from gdb_breakpoint_query to go to
 823      mi->event_channel.  One approach would be to just call
 824      gdb_breakpoint_query, and then use mi_out_put to send the current
 825      content of mi_outout into mi->event_channel.  However, that will
 826      break if anything is output to mi_uiout prior to calling the
 827      breakpoint_created notifications.  So, we use
 828      ui_out_redirect.  */
 829   ui_out_redirect (mi_uiout, mi->event_channel);
 830   TRY
 831     {
 832       gdb_breakpoint_query (mi_uiout, b->number, NULL);
 833     }
 834   CATCH (e, RETURN_MASK_ERROR)
 835     {
 836     }
 837   END_CATCH
 838
 839   ui_out_redirect (mi_uiout, NULL);
 840
 841   gdb_flush (mi->event_channel);
 842
 843   do_cleanups (old_chain);
 844 }
 845
 846 /* Emit notification about deleted breakpoint.  */
 847
 848 static void
 849 mi_breakpoint_deleted (struct breakpoint *b)
 850 {
 851   struct mi_interp *mi = (struct mi_interp *) top_level_interpreter_data ();
 852   struct cleanup *old_chain;
 853
 854   if (mi_suppress_notification.breakpoint)
 855     return;
 856
 857   if (b->number <= 0)
 858     return;
 859
 860   old_chain = make_cleanup_restore_target_terminal ();
 861   target_terminal_ours_for_output ();
 862
 863   fprintf_unfiltered (mi->event_channel, "breakpoint-deleted,id=\"%d\"",
 864                       b->number);
 865
 866   gdb_flush (mi->event_channel);
 867
 868   do_cleanups (old_chain);
 869 }
 870
 871 /* Emit notification about modified breakpoint.  */
 872
 873 static void
 874 mi_breakpoint_modified (struct breakpoint *b)
 875 {
 876   struct mi_interp *mi = (struct mi_interp *) top_level_interpreter_data ();
 877   struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
 878   struct cleanup *old_chain;
 879
 880   if (mi_suppress_notification.breakpoint)
 881     return;
 882
 883   if (b->number <= 0)
 884     return;
 885
 886   old_chain = make_cleanup_restore_target_terminal ();
 887   target_terminal_ours_for_output ();
 888
 889   fprintf_unfiltered (mi->event_channel,
 890                       "breakpoint-modified");
 891   /* We want the output from gdb_breakpoint_query to go to
 892      mi->event_channel.  One approach would be to just call
 893      gdb_breakpoint_query, and then use mi_out_put to send the current
 894      content of mi_outout into mi->event_channel.  However, that will
 895      break if anything is output to mi_uiout prior to calling the
 896      breakpoint_created notifications.  So, we use
 897      ui_out_redirect.  */
 898   ui_out_redirect (mi_uiout, mi->event_channel);
 899   TRY
 900     {
 901       gdb_breakpoint_query (mi_uiout, b->number, NULL);
 902     }
 903   CATCH (e, RETURN_MASK_ERROR)
 904     {
 905     }
 906   END_CATCH
 907
 908   ui_out_redirect (mi_uiout, NULL);
 909
 910   gdb_flush (mi->event_channel);
 911
 912   do_cleanups (old_chain);
 913 }
 914
 915 static int
 916 mi_output_running_pid (struct thread_info *info, void *arg)
 917 {
 918   ptid_t *ptid = (ptid_t *) arg;
 919
 920   if (ptid_get_pid (*ptid) == ptid_get_pid (info->ptid))
 921     fprintf_unfiltered (raw_stdout,
 922                         "*running,thread-id=\"%d\"\n",
 923                         info->global_num);
 924
 925   return 0;
 926 }
 927
 928 static int
 929 mi_inferior_count (struct inferior *inf, void *arg)
 930 {
 931   if (inf->pid != 0)
 932     {
 933       int *count_p = (int *) arg;
 934       (*count_p)++;
 935     }
 936
 937   return 0;
 938 }
 939
 940 static void
 941 mi_on_resume (ptid_t ptid)
 942 {
 943   struct thread_info *tp = NULL;
 944
 945   if (ptid_equal (ptid, minus_one_ptid) || ptid_is_pid (ptid))
 946     tp = inferior_thread ();
 947   else
 948     tp = find_thread_ptid (ptid);
 949
 950   /* Suppress output while calling an inferior function.  */
 951   if (tp->control.in_infcall)
 952     return;
 953
 954   /* To cater for older frontends, emit ^running, but do it only once
 955      per each command.  We do it here, since at this point we know
 956      that the target was successfully resumed, and in non-async mode,
 957      we won't return back to MI interpreter code until the target
 958      is done running, so delaying the output of "^running" until then
 959      will make it impossible for frontend to know what's going on.
 960
 961      In future (MI3), we'll be outputting "^done" here.  */
 962   if (!running_result_record_printed && mi_proceeded)
 963     {
 964       fprintf_unfiltered (raw_stdout, "%s^running\n",
 965                           current_token ? current_token : "");
 966     }
 967
 968   if (ptid_get_pid (ptid) == -1)
 969     fprintf_unfiltered (raw_stdout, "*running,thread-id=\"all\"\n");
 970   else if (ptid_is_pid (ptid))
 971     {
 972       int count = 0;
 973
 974       /* Backwards compatibility.  If there's only one inferior,
 975          output "all", otherwise, output each resumed thread
 976          individually.  */
 977       iterate_over_inferiors (mi_inferior_count, &count);
 978
 979       if (count == 1)
 980         fprintf_unfiltered (raw_stdout, "*running,thread-id=\"all\"\n");
 981       else
 982         iterate_over_threads (mi_output_running_pid, &ptid);
 983     }
 984   else
 985     {
 986       struct thread_info *ti = find_thread_ptid (ptid);
 987
 988       gdb_assert (ti);
 989       fprintf_unfiltered (raw_stdout, "*running,thread-id=\"%d\"\n",
 990                           ti->global_num);
 991     }
 992
 993   if (!running_result_record_printed && mi_proceeded)
 994     {
 995       running_result_record_printed = 1;
 996       /* This is what gdb used to do historically -- printing prompt even if
 997          it cannot actually accept any input.  This will be surely removed
 998          for MI3, and may be removed even earlier.  SYNC_EXECUTION is
 999          checked here because we only need to emit a prompt if a
1000          synchronous command was issued when the target is async.  */
1001       if (!target_can_async_p () || sync_execution)
1002         fputs_unfiltered ("(gdb) \n", raw_stdout);
1003     }
1004   gdb_flush (raw_stdout);
1005 }
1006
1007 static void
1008 mi_solib_loaded (struct so_list *solib)
1009 {
1010   struct mi_interp *mi = (struct mi_interp *) top_level_interpreter_data ();
1011   struct ui_out *uiout = interp_ui_out (top_level_interpreter ());
1012   struct cleanup *old_chain;
1013
1014   old_chain = make_cleanup_restore_target_terminal ();
1015   target_terminal_ours_for_output ();
1016
1017   fprintf_unfiltered (mi->event_channel, "library-loaded");
1018
1019   ui_out_redirect (uiout, mi->event_channel);
1020
1021   ui_out_field_string (uiout, "id", solib->so_original_name);
1022   ui_out_field_string (uiout, "target-name", solib->so_original_name);
1023   ui_out_field_string (uiout, "host-name", solib->so_name);
1024   ui_out_field_int (uiout, "symbols-loaded", solib->symbols_loaded);
1025   if (!gdbarch_has_global_solist (target_gdbarch ()))
1026     {
1027       ui_out_field_fmt (uiout, "thread-group", "i%d",
1028                         current_inferior ()->num);
1029     }
1030
1031   ui_out_redirect (uiout, NULL);
1032
1033   gdb_flush (mi->event_channel);
1034
1035   do_cleanups (old_chain);
1036 }
1037
1038 static void
1039 mi_solib_unloaded (struct so_list *solib)
1040 {
1041   struct mi_interp *mi = (struct mi_interp *) top_level_interpreter_data ();
1042   struct ui_out *uiout = interp_ui_out (top_level_interpreter ());
1043   struct cleanup *old_chain;
1044
1045   old_chain = make_cleanup_restore_target_terminal ();
1046   target_terminal_ours_for_output ();
1047
1048   fprintf_unfiltered (mi->event_channel, "library-unloaded");
1049
1050   ui_out_redirect (uiout, mi->event_channel);
1051
1052   ui_out_field_string (uiout, "id", solib->so_original_name);
1053   ui_out_field_string (uiout, "target-name", solib->so_original_name);
1054   ui_out_field_string (uiout, "host-name", solib->so_name);
1055   if (!gdbarch_has_global_solist (target_gdbarch ()))
1056     {
1057       ui_out_field_fmt (uiout, "thread-group", "i%d",
1058                         current_inferior ()->num);
1059     }
1060
1061   ui_out_redirect (uiout, NULL);
1062
1063   gdb_flush (mi->event_channel);
1064
1065   do_cleanups (old_chain);
1066 }
1067
1068 /* Emit notification about the command parameter change.  */
1069
1070 static void
1071 mi_command_param_changed (const char *param, const char *value)
1072 {
1073   struct mi_interp *mi = (struct mi_interp *) top_level_interpreter_data ();
1074   struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
1075   struct cleanup *old_chain;
1076
1077   if (mi_suppress_notification.cmd_param_changed)
1078     return;
1079
1080   old_chain = make_cleanup_restore_target_terminal ();
1081   target_terminal_ours_for_output ();
1082
1083   fprintf_unfiltered (mi->event_channel,
1084                       "cmd-param-changed");
1085
1086   ui_out_redirect (mi_uiout, mi->event_channel);
1087
1088   ui_out_field_string (mi_uiout, "param", param);
1089   ui_out_field_string (mi_uiout, "value", value);
1090
1091   ui_out_redirect (mi_uiout, NULL);
1092
1093   gdb_flush (mi->event_channel);
1094
1095   do_cleanups (old_chain);
1096 }
1097
1098 /* Emit notification about the target memory change.  */
1099
1100 static void
1101 mi_memory_changed (struct inferior *inferior, CORE_ADDR memaddr,
1102                    ssize_t len, const bfd_byte *myaddr)
1103 {
1104   struct mi_interp *mi = (struct mi_interp *) top_level_interpreter_data ();
1105   struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
1106   struct obj_section *sec;
1107   struct cleanup *old_chain;
1108
1109   if (mi_suppress_notification.memory)
1110     return;
1111
1112   old_chain = make_cleanup_restore_target_terminal ();
1113   target_terminal_ours_for_output ();
1114
1115   fprintf_unfiltered (mi->event_channel,
1116                       "memory-changed");
1117
1118   ui_out_redirect (mi_uiout, mi->event_channel);
1119
1120   ui_out_field_fmt (mi_uiout, "thread-group", "i%d", inferior->num);
1121   ui_out_field_core_addr (mi_uiout, "addr", target_gdbarch (), memaddr);
1122   ui_out_field_fmt (mi_uiout, "len", "%s", hex_string (len));
1123
1124   /* Append 'type=code' into notification if MEMADDR falls in the range of
1125      sections contain code.  */
1126   sec = find_pc_section (memaddr);
1127   if (sec != NULL && sec->objfile != NULL)
1128     {
1129       flagword flags = bfd_get_section_flags (sec->objfile->obfd,
1130                                               sec->the_bfd_section);
1131
1132       if (flags & SEC_CODE)
1133         ui_out_field_string (mi_uiout, "type", "code");
1134     }
1135
1136   ui_out_redirect (mi_uiout, NULL);
1137
1138   gdb_flush (mi->event_channel);
1139
1140   do_cleanups (old_chain);
1141 }
1142
1143 static int
1144 report_initial_inferior (struct inferior *inf, void *closure)
1145 {
1146   /* This function is called from mi_intepreter_init, and since
1147      mi_inferior_added assumes that inferior is fully initialized
1148      and top_level_interpreter_data is set, we cannot call
1149      it here.  */
1150   struct mi_interp *mi = (struct mi_interp *) closure;
1151   struct cleanup *old_chain;
1152
1153   old_chain = make_cleanup_restore_target_terminal ();
1154   target_terminal_ours_for_output ();
1155
1156   fprintf_unfiltered (mi->event_channel,
1157                       "thread-group-added,id=\"i%d\"",
1158                       inf->num);
1159   gdb_flush (mi->event_channel);
1160
1161   do_cleanups (old_chain);
1162   return 0;
1163 }
1164
1165 static struct ui_out *
1166 mi_ui_out (struct interp *interp)
1167 {
1168   struct mi_interp *mi = (struct mi_interp *) interp_data (interp);
1169
1170   return mi->mi_uiout;
1171 }
1172
1173 /* Save the original value of raw_stdout here when logging, so we can
1174    restore correctly when done.  */
1175
1176 static struct ui_file *saved_raw_stdout;
1177
1178 /* Do MI-specific logging actions; save raw_stdout, and change all
1179    the consoles to use the supplied ui-file(s).  */
1180
1181 static int
1182 mi_set_logging (struct interp *interp, int start_log,
1183                 struct ui_file *out, struct ui_file *logfile)
1184 {
1185   struct mi_interp *mi = (struct mi_interp *) interp_data (interp);
1186
1187   if (!mi)
1188     return 0;
1189
1190   if (start_log)
1191     {
1192       /* The tee created already is based on gdb_stdout, which for MI
1193          is a console and so we end up in an infinite loop of console
1194          writing to ui_file writing to console etc.  So discard the
1195          existing tee (it hasn't been used yet, and MI won't ever use
1196          it), and create one based on raw_stdout instead.  */
1197       if (logfile)
1198         {
1199           ui_file_delete (out);
1200           out = tee_file_new (raw_stdout, 0, logfile, 0);
1201         }
1202
1203       saved_raw_stdout = raw_stdout;
1204       raw_stdout = out;
1205     }
1206   else
1207     {
1208       raw_stdout = saved_raw_stdout;
1209       saved_raw_stdout = NULL;
1210     }
1211
1212   mi_console_set_raw (mi->out, raw_stdout);
1213   mi_console_set_raw (mi->err, raw_stdout);
1214   mi_console_set_raw (mi->log, raw_stdout);
1215   mi_console_set_raw (mi->targ, raw_stdout);
1216   mi_console_set_raw (mi->event_channel, raw_stdout);
1217
1218   return 1;
1219 }
1220
1221 extern initialize_file_ftype _initialize_mi_interp; /* -Wmissing-prototypes */
1222
1223 void
1224 _initialize_mi_interp (void)
1225 {
1226   static const struct interp_procs procs =
1227     {
1228       mi_interpreter_init,      /* init_proc */
1229       mi_interpreter_resume,    /* resume_proc */
1230       mi_interpreter_suspend,   /* suspend_proc */
1231       mi_interpreter_exec,      /* exec_proc */
1232       mi_ui_out,                /* ui_out_proc */
1233       mi_set_logging,           /* set_logging_proc */
1234       mi_command_loop           /* command_loop_proc */
1235     };
1236
1237   /* The various interpreter levels.  */
1238   interp_add (interp_new (INTERP_MI1, &procs));
1239   interp_add (interp_new (INTERP_MI2, &procs));
1240   interp_add (interp_new (INTERP_MI3, &procs));
1241   interp_add (interp_new (INTERP_MI, &procs));
1242 }