gdb/mi/mi-interp.c

   1 /* MI Interpreter Definitions and Commands for GDB, the GNU debugger.
   2
   3    Copyright (C) 2002-2018 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 "observable.h"
  34 #include "gdbthread.h"
  35 #include "solist.h"
  36 #include "objfiles.h"
  37 #include "tracepoint.h"
  38 #include "cli-out.h"
  39 #include "thread-fsm.h"
  40 #include "cli/cli-interp.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
  48 /* These are hooks that we put in place while doing interpreter_exec
  49    so we can report interesting things that happened "behind the MI's
  50    back" in this command.  */
  51
  52 static int mi_interp_query_hook (const char *ctlstr, va_list ap)
  53   ATTRIBUTE_PRINTF (1, 0);
  54
  55 static void mi_insert_notify_hooks (void);
  56 static void mi_remove_notify_hooks (void);
  57
  58 static void mi_on_signal_received (enum gdb_signal siggnal);
  59 static void mi_on_end_stepping_range (void);
  60 static void mi_on_signal_exited (enum gdb_signal siggnal);
  61 static void mi_on_exited (int exitstatus);
  62 static void mi_on_normal_stop (struct bpstats *bs, int print_frame);
  63 static void mi_on_no_history (void);
  64
  65 static void mi_new_thread (struct thread_info *t);
  66 static void mi_thread_exit (struct thread_info *t, int silent);
  67 static void mi_record_changed (struct inferior*, int, const char *,
  68                                const char *);
  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 /* Display the MI prompt.  */
  92
  93 static void
  94 display_mi_prompt (struct mi_interp *mi)
  95 {
  96   struct ui *ui = current_ui;
  97
  98   fputs_unfiltered ("(gdb) \n", mi->raw_stdout);
  99   gdb_flush (mi->raw_stdout);
 100   ui->prompt_state = PROMPTED;
 101 }
 102
 103 /* Returns the INTERP's data cast as mi_interp if INTERP is an MI, and
 104    returns NULL otherwise.  */
 105
 106 static struct mi_interp *
 107 as_mi_interp (struct interp *interp)
 108 {
 109   return dynamic_cast<mi_interp *> (interp);
 110 }
 111
 112 void
 113 mi_interp::init (bool top_level)
 114 {
 115   mi_interp *mi = this;
 116   int mi_version;
 117
 118   /* Store the current output channel, so that we can create a console
 119      channel that encapsulates and prefixes all gdb_output-type bits
 120      coming from the rest of the debugger.  */
 121   mi->raw_stdout = gdb_stdout;
 122
 123   /* Create MI console channels, each with a different prefix so they
 124      can be distinguished.  */
 125   mi->out = new mi_console_file (mi->raw_stdout, "~", '"');
 126   mi->err = new mi_console_file (mi->raw_stdout, "&", '"');
 127   mi->log = mi->err;
 128   mi->targ = new mi_console_file (mi->raw_stdout, "@", '"');
 129   mi->event_channel = new mi_console_file (mi->raw_stdout, "=", 0);
 130
 131   /* INTERP_MI selects the most recent released version.  "mi2" was
 132      released as part of GDB 6.0.  */
 133   if (strcmp (name (), INTERP_MI) == 0)
 134     mi_version = 2;
 135   else if (strcmp (name (), INTERP_MI1) == 0)
 136     mi_version = 1;
 137   else if (strcmp (name (), INTERP_MI2) == 0)
 138     mi_version = 2;
 139   else if (strcmp (name (), INTERP_MI3) == 0)
 140     mi_version = 3;
 141   else
 142     gdb_assert_not_reached ("unhandled MI version");
 143
 144   mi->mi_uiout = mi_out_new (mi_version);
 145   mi->cli_uiout = cli_out_new (mi->out);
 146
 147   if (top_level)
 148     {
 149       /* The initial inferior is created before this function is
 150          called, so we need to report it explicitly.  Use iteration in
 151          case future version of GDB creates more than one inferior
 152          up-front.  */
 153       iterate_over_inferiors (report_initial_inferior, mi);
 154     }
 155 }
 156
 157 void
 158 mi_interp::resume ()
 159 {
 160   struct mi_interp *mi = this;
 161   struct ui *ui = current_ui;
 162
 163   /* As per hack note in mi_interpreter_init, swap in the output
 164      channels... */
 165   gdb_setup_readline (0);
 166
 167   ui->call_readline = gdb_readline_no_editing_callback;
 168   ui->input_handler = mi_execute_command_input_handler;
 169
 170   gdb_stdout = mi->out;
 171   /* Route error and log output through the MI.  */
 172   gdb_stderr = mi->err;
 173   gdb_stdlog = mi->log;
 174   /* Route target output through the MI.  */
 175   gdb_stdtarg = mi->targ;
 176   /* Route target error through the MI as well.  */
 177   gdb_stdtargerr = mi->targ;
 178
 179   /* Replace all the hooks that we know about.  There really needs to
 180      be a better way of doing this... */
 181   clear_interpreter_hooks ();
 182
 183   deprecated_show_load_progress = mi_load_progress;
 184 }
 185
 186 void
 187 mi_interp::suspend ()
 188 {
 189   gdb_disable_readline ();
 190 }
 191
 192 gdb_exception
 193 mi_interp::exec (const char *command)
 194 {
 195   mi_execute_command_wrapper (command);
 196   return exception_none;
 197 }
 198
 199 void
 200 mi_cmd_interpreter_exec (const char *command, char **argv, int argc)
 201 {
 202   struct interp *interp_to_use;
 203   int i;
 204
 205   if (argc < 2)
 206     error (_("-interpreter-exec: "
 207              "Usage: -interpreter-exec interp command"));
 208
 209   interp_to_use = interp_lookup (current_ui, argv[0]);
 210   if (interp_to_use == NULL)
 211     error (_("-interpreter-exec: could not find interpreter \"%s\""),
 212            argv[0]);
 213
 214   /* Note that unlike the CLI version of this command, we don't
 215      actually set INTERP_TO_USE as the current interpreter, as we
 216      still want gdb_stdout, etc. to point at MI streams.  */
 217
 218   /* Insert the MI out hooks, making sure to also call the
 219      interpreter's hooks if it has any.  */
 220   /* KRS: We shouldn't need this... Events should be installed and
 221      they should just ALWAYS fire something out down the MI
 222      channel.  */
 223   mi_insert_notify_hooks ();
 224
 225   /* Now run the code.  */
 226
 227   std::string mi_error_message;
 228   for (i = 1; i < argc; i++)
 229     {
 230       struct gdb_exception e = interp_exec (interp_to_use, argv[i]);
 231
 232       if (e.reason < 0)
 233         {
 234           mi_error_message = e.message;
 235           break;
 236         }
 237     }
 238
 239   mi_remove_notify_hooks ();
 240
 241   if (!mi_error_message.empty ())
 242     error ("%s", mi_error_message.c_str ());
 243 }
 244
 245 /* This inserts a number of hooks that are meant to produce
 246    async-notify ("=") MI messages while running commands in another
 247    interpreter using mi_interpreter_exec.  The canonical use for this
 248    is to allow access to the gdb CLI interpreter from within the MI,
 249    while still producing MI style output when actions in the CLI
 250    command change GDB's state.  */
 251
 252 static void
 253 mi_insert_notify_hooks (void)
 254 {
 255   deprecated_query_hook = mi_interp_query_hook;
 256 }
 257
 258 static void
 259 mi_remove_notify_hooks (void)
 260 {
 261   deprecated_query_hook = NULL;
 262 }
 263
 264 static int
 265 mi_interp_query_hook (const char *ctlstr, va_list ap)
 266 {
 267   return 1;
 268 }
 269
 270 static void
 271 mi_execute_command_wrapper (const char *cmd)
 272 {
 273   struct ui *ui = current_ui;
 274
 275   mi_execute_command (cmd, ui->instream == ui->stdin_stream);
 276 }
 277
 278 /* Observer for the synchronous_command_done notification.  */
 279
 280 static void
 281 mi_on_sync_execution_done (void)
 282 {
 283   struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
 284
 285   if (mi == NULL)
 286     return;
 287
 288   /* If MI is sync, then output the MI prompt now, indicating we're
 289      ready for further input.  */
 290   if (!mi_async_p ())
 291     display_mi_prompt (mi);
 292 }
 293
 294 /* mi_execute_command_wrapper wrapper suitable for INPUT_HANDLER.  */
 295
 296 static void
 297 mi_execute_command_input_handler (char *cmd)
 298 {
 299   struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
 300   struct ui *ui = current_ui;
 301
 302   ui->prompt_state = PROMPT_NEEDED;
 303
 304   mi_execute_command_wrapper (cmd);
 305
 306   /* Print a prompt, indicating we're ready for further input, unless
 307      we just started a synchronous command.  In that case, we're about
 308      to go back to the event loop and will output the prompt in the
 309      'synchronous_command_done' observer when the target next
 310      stops.  */
 311   if (ui->prompt_state == PROMPT_NEEDED)
 312     display_mi_prompt (mi);
 313 }
 314
 315 void
 316 mi_interp::pre_command_loop ()
 317 {
 318   struct mi_interp *mi = this;
 319
 320   /* Turn off 8 bit strings in quoted output.  Any character with the
 321      high bit set is printed using C's octal format.  */
 322   sevenbit_strings = 1;
 323
 324   /* Tell the world that we're alive.  */
 325   display_mi_prompt (mi);
 326 }
 327
 328 static void
 329 mi_new_thread (struct thread_info *t)
 330 {
 331   SWITCH_THRU_ALL_UIS ()
 332     {
 333       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
 334
 335       if (mi == NULL)
 336         continue;
 337
 338       target_terminal::scoped_restore_terminal_state term_state;
 339       target_terminal::ours_for_output ();
 340
 341       fprintf_unfiltered (mi->event_channel,
 342                           "thread-created,id=\"%d\",group-id=\"i%d\"",
 343                           t->global_num, t->inf->num);
 344       gdb_flush (mi->event_channel);
 345     }
 346 }
 347
 348 static void
 349 mi_thread_exit (struct thread_info *t, int silent)
 350 {
 351   if (silent)
 352     return;
 353
 354   SWITCH_THRU_ALL_UIS ()
 355     {
 356       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
 357
 358       if (mi == NULL)
 359         continue;
 360
 361       target_terminal::scoped_restore_terminal_state term_state;
 362       target_terminal::ours_for_output ();
 363       fprintf_unfiltered (mi->event_channel,
 364                           "thread-exited,id=\"%d\",group-id=\"i%d\"",
 365                           t->global_num, t->inf->num);
 366       gdb_flush (mi->event_channel);
 367     }
 368 }
 369
 370 /* Emit notification on changing the state of record.  */
 371
 372 static void
 373 mi_record_changed (struct inferior *inferior, int started, const char *method,
 374                    const char *format)
 375 {
 376   SWITCH_THRU_ALL_UIS ()
 377     {
 378       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
 379
 380       if (mi == NULL)
 381         continue;
 382
 383       target_terminal::scoped_restore_terminal_state term_state;
 384       target_terminal::ours_for_output ();
 385
 386       if (started)
 387         {
 388           if (format != NULL)
 389             {
 390               fprintf_unfiltered (mi->event_channel,
 391                                   "record-started,thread-group=\"i%d\","
 392                                   "method=\"%s\",format=\"%s\"",
 393                                   inferior->num, method, format);
 394             }
 395           else
 396             {
 397               fprintf_unfiltered (mi->event_channel,
 398                                   "record-started,thread-group=\"i%d\","
 399                                   "method=\"%s\"",
 400                                   inferior->num, method);
 401             }
 402         }
 403       else
 404         {
 405           fprintf_unfiltered (mi->event_channel,
 406                               "record-stopped,thread-group=\"i%d\"",
 407                               inferior->num);
 408         }
 409
 410       gdb_flush (mi->event_channel);
 411     }
 412 }
 413
 414 static void
 415 mi_inferior_added (struct inferior *inf)
 416 {
 417   SWITCH_THRU_ALL_UIS ()
 418     {
 419       struct interp *interp;
 420       struct mi_interp *mi;
 421
 422       /* We'll be called once for the initial inferior, before the top
 423          level interpreter is set.  */
 424       interp = top_level_interpreter ();
 425       if (interp == NULL)
 426         continue;
 427
 428       mi = as_mi_interp (interp);
 429       if (mi == NULL)
 430         continue;
 431
 432       target_terminal::scoped_restore_terminal_state term_state;
 433       target_terminal::ours_for_output ();
 434
 435       fprintf_unfiltered (mi->event_channel,
 436                           "thread-group-added,id=\"i%d\"",
 437                           inf->num);
 438       gdb_flush (mi->event_channel);
 439     }
 440 }
 441
 442 static void
 443 mi_inferior_appeared (struct inferior *inf)
 444 {
 445   SWITCH_THRU_ALL_UIS ()
 446     {
 447       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
 448
 449       if (mi == NULL)
 450         continue;
 451
 452       target_terminal::scoped_restore_terminal_state term_state;
 453       target_terminal::ours_for_output ();
 454
 455       fprintf_unfiltered (mi->event_channel,
 456                           "thread-group-started,id=\"i%d\",pid=\"%d\"",
 457                           inf->num, inf->pid);
 458       gdb_flush (mi->event_channel);
 459     }
 460 }
 461
 462 static void
 463 mi_inferior_exit (struct inferior *inf)
 464 {
 465   SWITCH_THRU_ALL_UIS ()
 466     {
 467       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
 468
 469       if (mi == NULL)
 470         continue;
 471
 472       target_terminal::scoped_restore_terminal_state term_state;
 473       target_terminal::ours_for_output ();
 474
 475       if (inf->has_exit_code)
 476         fprintf_unfiltered (mi->event_channel,
 477                             "thread-group-exited,id=\"i%d\",exit-code=\"%s\"",
 478                             inf->num, int_string (inf->exit_code, 8, 0, 0, 1));
 479       else
 480         fprintf_unfiltered (mi->event_channel,
 481                             "thread-group-exited,id=\"i%d\"", inf->num);
 482
 483       gdb_flush (mi->event_channel);
 484     }
 485 }
 486
 487 static void
 488 mi_inferior_removed (struct inferior *inf)
 489 {
 490   SWITCH_THRU_ALL_UIS ()
 491     {
 492       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
 493
 494       if (mi == NULL)
 495         continue;
 496
 497       target_terminal::scoped_restore_terminal_state term_state;
 498       target_terminal::ours_for_output ();
 499
 500       fprintf_unfiltered (mi->event_channel,
 501                           "thread-group-removed,id=\"i%d\"",
 502                           inf->num);
 503       gdb_flush (mi->event_channel);
 504     }
 505 }
 506
 507 /* Return the MI interpreter, if it is active -- either because it's
 508    the top-level interpreter or the interpreter executing the current
 509    command.  Returns NULL if the MI interpreter is not being used.  */
 510
 511 static struct mi_interp *
 512 find_mi_interp (void)
 513 {
 514   struct mi_interp *mi;
 515
 516   mi = as_mi_interp (top_level_interpreter ());
 517   if (mi != NULL)
 518     return mi;
 519
 520   mi = as_mi_interp (command_interp ());
 521   if (mi != NULL)
 522     return mi;
 523
 524   return NULL;
 525 }
 526
 527 /* Observers for several run control events that print why the
 528    inferior has stopped to both the the MI event channel and to the MI
 529    console.  If the MI interpreter is not active, print nothing.  */
 530
 531 /* Observer for the signal_received notification.  */
 532
 533 static void
 534 mi_on_signal_received (enum gdb_signal siggnal)
 535 {
 536   SWITCH_THRU_ALL_UIS ()
 537     {
 538       struct mi_interp *mi = find_mi_interp ();
 539
 540       if (mi == NULL)
 541         continue;
 542
 543       print_signal_received_reason (mi->mi_uiout, siggnal);
 544       print_signal_received_reason (mi->cli_uiout, siggnal);
 545     }
 546 }
 547
 548 /* Observer for the end_stepping_range notification.  */
 549
 550 static void
 551 mi_on_end_stepping_range (void)
 552 {
 553   SWITCH_THRU_ALL_UIS ()
 554     {
 555       struct mi_interp *mi = find_mi_interp ();
 556
 557       if (mi == NULL)
 558         continue;
 559
 560       print_end_stepping_range_reason (mi->mi_uiout);
 561       print_end_stepping_range_reason (mi->cli_uiout);
 562     }
 563 }
 564
 565 /* Observer for the signal_exited notification.  */
 566
 567 static void
 568 mi_on_signal_exited (enum gdb_signal siggnal)
 569 {
 570   SWITCH_THRU_ALL_UIS ()
 571     {
 572       struct mi_interp *mi = find_mi_interp ();
 573
 574       if (mi == NULL)
 575         continue;
 576
 577       print_signal_exited_reason (mi->mi_uiout, siggnal);
 578       print_signal_exited_reason (mi->cli_uiout, siggnal);
 579     }
 580 }
 581
 582 /* Observer for the exited notification.  */
 583
 584 static void
 585 mi_on_exited (int exitstatus)
 586 {
 587   SWITCH_THRU_ALL_UIS ()
 588     {
 589       struct mi_interp *mi = find_mi_interp ();
 590
 591       if (mi == NULL)
 592         continue;
 593
 594       print_exited_reason (mi->mi_uiout, exitstatus);
 595       print_exited_reason (mi->cli_uiout, exitstatus);
 596     }
 597 }
 598
 599 /* Observer for the no_history notification.  */
 600
 601 static void
 602 mi_on_no_history (void)
 603 {
 604   SWITCH_THRU_ALL_UIS ()
 605     {
 606       struct mi_interp *mi = find_mi_interp ();
 607
 608       if (mi == NULL)
 609         continue;
 610
 611       print_no_history_reason (mi->mi_uiout);
 612       print_no_history_reason (mi->cli_uiout);
 613     }
 614 }
 615
 616 static void
 617 mi_on_normal_stop_1 (struct bpstats *bs, int print_frame)
 618 {
 619   /* Since this can be called when CLI command is executing,
 620      using cli interpreter, be sure to use MI uiout for output,
 621      not the current one.  */
 622   struct ui_out *mi_uiout = top_level_interpreter ()->interp_ui_out ();
 623   struct mi_interp *mi = (struct mi_interp *) top_level_interpreter ();
 624
 625   if (print_frame)
 626     {
 627       struct thread_info *tp;
 628       int core;
 629       struct interp *console_interp;
 630
 631       tp = inferior_thread ();
 632
 633       if (tp->thread_fsm != NULL
 634           && thread_fsm_finished_p (tp->thread_fsm))
 635         {
 636           enum async_reply_reason reason;
 637
 638           reason = thread_fsm_async_reply_reason (tp->thread_fsm);
 639           mi_uiout->field_string ("reason", async_reason_lookup (reason));
 640         }
 641       print_stop_event (mi_uiout);
 642
 643       console_interp = interp_lookup (current_ui, INTERP_CONSOLE);
 644       if (should_print_stop_to_console (console_interp, tp))
 645         print_stop_event (mi->cli_uiout);
 646
 647       mi_uiout->field_int ("thread-id", tp->global_num);
 648       if (non_stop)
 649         {
 650           ui_out_emit_list list_emitter (mi_uiout, "stopped-threads");
 651
 652           mi_uiout->field_int (NULL, tp->global_num);
 653         }
 654       else
 655         mi_uiout->field_string ("stopped-threads", "all");
 656
 657       core = target_core_of_thread (tp->ptid);
 658       if (core != -1)
 659         mi_uiout->field_int ("core", core);
 660     }
 661
 662   fputs_unfiltered ("*stopped", mi->raw_stdout);
 663   mi_out_put (mi_uiout, mi->raw_stdout);
 664   mi_out_rewind (mi_uiout);
 665   mi_print_timing_maybe (mi->raw_stdout);
 666   fputs_unfiltered ("\n", mi->raw_stdout);
 667   gdb_flush (mi->raw_stdout);
 668 }
 669
 670 static void
 671 mi_on_normal_stop (struct bpstats *bs, int print_frame)
 672 {
 673   SWITCH_THRU_ALL_UIS ()
 674     {
 675       if (as_mi_interp (top_level_interpreter ()) == NULL)
 676         continue;
 677
 678       mi_on_normal_stop_1 (bs, print_frame);
 679     }
 680 }
 681
 682 static void
 683 mi_about_to_proceed (void)
 684 {
 685   /* Suppress output while calling an inferior function.  */
 686
 687   if (!ptid_equal (inferior_ptid, null_ptid))
 688     {
 689       struct thread_info *tp = inferior_thread ();
 690
 691       if (tp->control.in_infcall)
 692         return;
 693     }
 694
 695   mi_proceeded = 1;
 696 }
 697
 698 /* When the element is non-zero, no MI notifications will be emitted in
 699    response to the corresponding observers.  */
 700
 701 struct mi_suppress_notification mi_suppress_notification =
 702   {
 703     0,
 704     0,
 705     0,
 706     0,
 707   };
 708
 709 /* Emit notification on changing a traceframe.  */
 710
 711 static void
 712 mi_traceframe_changed (int tfnum, int tpnum)
 713 {
 714   if (mi_suppress_notification.traceframe)
 715     return;
 716
 717   SWITCH_THRU_ALL_UIS ()
 718     {
 719       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
 720
 721       if (mi == NULL)
 722         continue;
 723
 724       target_terminal::scoped_restore_terminal_state term_state;
 725       target_terminal::ours_for_output ();
 726
 727       if (tfnum >= 0)
 728         fprintf_unfiltered (mi->event_channel, "traceframe-changed,"
 729                             "num=\"%d\",tracepoint=\"%d\"\n",
 730                             tfnum, tpnum);
 731       else
 732         fprintf_unfiltered (mi->event_channel, "traceframe-changed,end");
 733
 734       gdb_flush (mi->event_channel);
 735     }
 736 }
 737
 738 /* Emit notification on creating a trace state variable.  */
 739
 740 static void
 741 mi_tsv_created (const struct trace_state_variable *tsv)
 742 {
 743   SWITCH_THRU_ALL_UIS ()
 744     {
 745       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
 746
 747       if (mi == NULL)
 748         continue;
 749
 750       target_terminal::scoped_restore_terminal_state term_state;
 751       target_terminal::ours_for_output ();
 752
 753       fprintf_unfiltered (mi->event_channel, "tsv-created,"
 754                           "name=\"%s\",initial=\"%s\"\n",
 755                           tsv->name.c_str (), plongest (tsv->initial_value));
 756
 757       gdb_flush (mi->event_channel);
 758     }
 759 }
 760
 761 /* Emit notification on deleting a trace state variable.  */
 762
 763 static void
 764 mi_tsv_deleted (const struct trace_state_variable *tsv)
 765 {
 766   SWITCH_THRU_ALL_UIS ()
 767     {
 768       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
 769
 770       if (mi == NULL)
 771         continue;
 772
 773       target_terminal::scoped_restore_terminal_state term_state;
 774       target_terminal::ours_for_output ();
 775
 776       if (tsv != NULL)
 777         fprintf_unfiltered (mi->event_channel, "tsv-deleted,"
 778                             "name=\"%s\"\n", tsv->name.c_str ());
 779       else
 780         fprintf_unfiltered (mi->event_channel, "tsv-deleted\n");
 781
 782       gdb_flush (mi->event_channel);
 783     }
 784 }
 785
 786 /* Emit notification on modifying a trace state variable.  */
 787
 788 static void
 789 mi_tsv_modified (const struct trace_state_variable *tsv)
 790 {
 791   SWITCH_THRU_ALL_UIS ()
 792     {
 793       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
 794       struct ui_out *mi_uiout;
 795
 796       if (mi == NULL)
 797         continue;
 798
 799       mi_uiout = top_level_interpreter ()->interp_ui_out ();
 800
 801       target_terminal::scoped_restore_terminal_state term_state;
 802       target_terminal::ours_for_output ();
 803
 804       fprintf_unfiltered (mi->event_channel,
 805                           "tsv-modified");
 806
 807       mi_uiout->redirect (mi->event_channel);
 808
 809       mi_uiout->field_string ("name", tsv->name);
 810       mi_uiout->field_string ("initial",
 811                            plongest (tsv->initial_value));
 812       if (tsv->value_known)
 813         mi_uiout->field_string ("current", plongest (tsv->value));
 814
 815       mi_uiout->redirect (NULL);
 816
 817       gdb_flush (mi->event_channel);
 818     }
 819 }
 820
 821 /* Print breakpoint BP on MI's event channel.  */
 822
 823 static void
 824 mi_print_breakpoint_for_event (struct mi_interp *mi, breakpoint *bp)
 825 {
 826   ui_out *mi_uiout = mi->interp_ui_out ();
 827
 828   /* We want the output from print_breakpoint to go to
 829      mi->event_channel.  One approach would be to just call
 830      print_breakpoint, and then use mi_out_put to send the current
 831      content of mi_uiout into mi->event_channel.  However, that will
 832      break if anything is output to mi_uiout prior to calling the
 833      breakpoint_created notifications.  So, we use
 834      ui_out_redirect.  */
 835   mi_uiout->redirect (mi->event_channel);
 836
 837   TRY
 838     {
 839       scoped_restore restore_uiout
 840         = make_scoped_restore (&current_uiout, mi_uiout);
 841
 842       print_breakpoint (bp);
 843     }
 844   CATCH (ex, RETURN_MASK_ALL)
 845     {
 846       exception_print (gdb_stderr, ex);
 847     }
 848   END_CATCH
 849
 850   mi_uiout->redirect (NULL);
 851 }
 852
 853 /* Emit notification about a created breakpoint.  */
 854
 855 static void
 856 mi_breakpoint_created (struct breakpoint *b)
 857 {
 858   if (mi_suppress_notification.breakpoint)
 859     return;
 860
 861   if (b->number <= 0)
 862     return;
 863
 864   SWITCH_THRU_ALL_UIS ()
 865     {
 866       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
 867
 868       if (mi == NULL)
 869         continue;
 870
 871       target_terminal::scoped_restore_terminal_state term_state;
 872       target_terminal::ours_for_output ();
 873
 874       fprintf_unfiltered (mi->event_channel,
 875                           "breakpoint-created");
 876       mi_print_breakpoint_for_event (mi, b);
 877
 878       gdb_flush (mi->event_channel);
 879     }
 880 }
 881
 882 /* Emit notification about deleted breakpoint.  */
 883
 884 static void
 885 mi_breakpoint_deleted (struct breakpoint *b)
 886 {
 887   if (mi_suppress_notification.breakpoint)
 888     return;
 889
 890   if (b->number <= 0)
 891     return;
 892
 893   SWITCH_THRU_ALL_UIS ()
 894     {
 895       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
 896
 897       if (mi == NULL)
 898         continue;
 899
 900       target_terminal::scoped_restore_terminal_state term_state;
 901       target_terminal::ours_for_output ();
 902
 903       fprintf_unfiltered (mi->event_channel, "breakpoint-deleted,id=\"%d\"",
 904                           b->number);
 905
 906       gdb_flush (mi->event_channel);
 907     }
 908 }
 909
 910 /* Emit notification about modified breakpoint.  */
 911
 912 static void
 913 mi_breakpoint_modified (struct breakpoint *b)
 914 {
 915   if (mi_suppress_notification.breakpoint)
 916     return;
 917
 918   if (b->number <= 0)
 919     return;
 920
 921   SWITCH_THRU_ALL_UIS ()
 922     {
 923       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
 924
 925       if (mi == NULL)
 926         continue;
 927
 928       target_terminal::scoped_restore_terminal_state term_state;
 929       target_terminal::ours_for_output ();
 930       fprintf_unfiltered (mi->event_channel,
 931                           "breakpoint-modified");
 932       mi_print_breakpoint_for_event (mi, b);
 933
 934       gdb_flush (mi->event_channel);
 935     }
 936 }
 937
 938 static void
 939 mi_output_running (struct thread_info *thread)
 940 {
 941   SWITCH_THRU_ALL_UIS ()
 942     {
 943       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
 944
 945       if (mi == NULL)
 946         continue;
 947
 948       fprintf_unfiltered (mi->raw_stdout,
 949                           "*running,thread-id=\"%d\"\n",
 950                           thread->global_num);
 951     }
 952 }
 953
 954 static void
 955 mi_on_resume_1 (struct mi_interp *mi, ptid_t ptid)
 956 {
 957   /* To cater for older frontends, emit ^running, but do it only once
 958      per each command.  We do it here, since at this point we know
 959      that the target was successfully resumed, and in non-async mode,
 960      we won't return back to MI interpreter code until the target
 961      is done running, so delaying the output of "^running" until then
 962      will make it impossible for frontend to know what's going on.
 963
 964      In future (MI3), we'll be outputting "^done" here.  */
 965   if (!running_result_record_printed && mi_proceeded)
 966     {
 967       fprintf_unfiltered (mi->raw_stdout, "%s^running\n",
 968                           current_token ? current_token : "");
 969     }
 970
 971   if (ptid_get_pid (ptid) == -1)
 972     fprintf_unfiltered (mi->raw_stdout, "*running,thread-id=\"all\"\n");
 973   else if (ptid_is_pid (ptid))
 974     {
 975       int count = 0;
 976       inferior *inf;
 977
 978       /* Backwards compatibility.  If there's only one inferior,
 979          output "all", otherwise, output each resumed thread
 980          individually.  */
 981       ALL_INFERIORS (inf)
 982         if (inf->pid != 0)
 983           {
 984             count++;
 985             if (count > 1)
 986               break;
 987           }
 988
 989       if (count == 1)
 990         fprintf_unfiltered (mi->raw_stdout, "*running,thread-id=\"all\"\n");
 991       else
 992         {
 993           thread_info *tp;
 994           inferior *curinf = current_inferior ();
 995
 996           ALL_NON_EXITED_THREADS (tp)
 997             if (tp->inf == curinf)
 998               mi_output_running (tp);
 999         }
1000     }
1001   else
1002     {
1003       thread_info *ti = find_thread_ptid (ptid);
1004
1005       gdb_assert (ti);
1006       mi_output_running (ti);
1007     }
1008
1009   if (!running_result_record_printed && mi_proceeded)
1010     {
1011       running_result_record_printed = 1;
1012       /* This is what gdb used to do historically -- printing prompt
1013          even if it cannot actually accept any input.  This will be
1014          surely removed for MI3, and may be removed even earlier.  */
1015       if (current_ui->prompt_state == PROMPT_BLOCKED)
1016         fputs_unfiltered ("(gdb) \n", mi->raw_stdout);
1017     }
1018   gdb_flush (mi->raw_stdout);
1019 }
1020
1021 static void
1022 mi_on_resume (ptid_t ptid)
1023 {
1024   struct thread_info *tp = NULL;
1025
1026   if (ptid_equal (ptid, minus_one_ptid) || ptid_is_pid (ptid))
1027     tp = inferior_thread ();
1028   else
1029     tp = find_thread_ptid (ptid);
1030
1031   /* Suppress output while calling an inferior function.  */
1032   if (tp->control.in_infcall)
1033     return;
1034
1035   SWITCH_THRU_ALL_UIS ()
1036     {
1037       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
1038
1039       if (mi == NULL)
1040         continue;
1041
1042       target_terminal::scoped_restore_terminal_state term_state;
1043       target_terminal::ours_for_output ();
1044
1045       mi_on_resume_1 (mi, ptid);
1046     }
1047 }
1048
1049 /* See mi-interp.h.  */
1050
1051 void
1052 mi_output_solib_attribs (ui_out *uiout, struct so_list *solib)
1053 {
1054   struct gdbarch *gdbarch = target_gdbarch ();
1055
1056   uiout->field_string ("id", solib->so_original_name);
1057   uiout->field_string ("target-name", solib->so_original_name);
1058   uiout->field_string ("host-name", solib->so_name);
1059   uiout->field_int ("symbols-loaded", solib->symbols_loaded);
1060   if (!gdbarch_has_global_solist (target_gdbarch ()))
1061       uiout->field_fmt ("thread-group", "i%d", current_inferior ()->num);
1062
1063   ui_out_emit_list list_emitter (uiout, "ranges");
1064   ui_out_emit_tuple tuple_emitter (uiout, NULL);
1065   if (solib->addr_high != 0)
1066     {
1067       uiout->field_core_addr ("from", gdbarch, solib->addr_low);
1068       uiout->field_core_addr ("to", gdbarch, solib->addr_high);
1069     }
1070 }
1071
1072 static void
1073 mi_solib_loaded (struct so_list *solib)
1074 {
1075   SWITCH_THRU_ALL_UIS ()
1076     {
1077       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
1078       struct ui_out *uiout;
1079
1080       if (mi == NULL)
1081         continue;
1082
1083       uiout = top_level_interpreter ()->interp_ui_out ();
1084
1085       target_terminal::scoped_restore_terminal_state term_state;
1086       target_terminal::ours_for_output ();
1087
1088       fprintf_unfiltered (mi->event_channel, "library-loaded");
1089
1090       uiout->redirect (mi->event_channel);
1091
1092       mi_output_solib_attribs (uiout, solib);
1093
1094       uiout->redirect (NULL);
1095
1096       gdb_flush (mi->event_channel);
1097     }
1098 }
1099
1100 static void
1101 mi_solib_unloaded (struct so_list *solib)
1102 {
1103   SWITCH_THRU_ALL_UIS ()
1104     {
1105       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
1106       struct ui_out *uiout;
1107
1108       if (mi == NULL)
1109         continue;
1110
1111       uiout = top_level_interpreter ()->interp_ui_out ();
1112
1113       target_terminal::scoped_restore_terminal_state term_state;
1114       target_terminal::ours_for_output ();
1115
1116       fprintf_unfiltered (mi->event_channel, "library-unloaded");
1117
1118       uiout->redirect (mi->event_channel);
1119
1120       uiout->field_string ("id", solib->so_original_name);
1121       uiout->field_string ("target-name", solib->so_original_name);
1122       uiout->field_string ("host-name", solib->so_name);
1123       if (!gdbarch_has_global_solist (target_gdbarch ()))
1124         {
1125           uiout->field_fmt ("thread-group", "i%d", current_inferior ()->num);
1126         }
1127
1128       uiout->redirect (NULL);
1129
1130       gdb_flush (mi->event_channel);
1131     }
1132 }
1133
1134 /* Emit notification about the command parameter change.  */
1135
1136 static void
1137 mi_command_param_changed (const char *param, const char *value)
1138 {
1139   if (mi_suppress_notification.cmd_param_changed)
1140     return;
1141
1142   SWITCH_THRU_ALL_UIS ()
1143     {
1144       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
1145       struct ui_out *mi_uiout;
1146
1147       if (mi == NULL)
1148         continue;
1149
1150       mi_uiout = top_level_interpreter ()->interp_ui_out ();
1151
1152       target_terminal::scoped_restore_terminal_state term_state;
1153       target_terminal::ours_for_output ();
1154
1155       fprintf_unfiltered (mi->event_channel, "cmd-param-changed");
1156
1157       mi_uiout->redirect (mi->event_channel);
1158
1159       mi_uiout->field_string ("param", param);
1160       mi_uiout->field_string ("value", value);
1161
1162       mi_uiout->redirect (NULL);
1163
1164       gdb_flush (mi->event_channel);
1165     }
1166 }
1167
1168 /* Emit notification about the target memory change.  */
1169
1170 static void
1171 mi_memory_changed (struct inferior *inferior, CORE_ADDR memaddr,
1172                    ssize_t len, const bfd_byte *myaddr)
1173 {
1174   if (mi_suppress_notification.memory)
1175     return;
1176
1177   SWITCH_THRU_ALL_UIS ()
1178     {
1179       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
1180       struct ui_out *mi_uiout;
1181       struct obj_section *sec;
1182
1183       if (mi == NULL)
1184         continue;
1185
1186       mi_uiout = top_level_interpreter ()->interp_ui_out ();
1187
1188       target_terminal::scoped_restore_terminal_state term_state;
1189       target_terminal::ours_for_output ();
1190
1191       fprintf_unfiltered (mi->event_channel, "memory-changed");
1192
1193       mi_uiout->redirect (mi->event_channel);
1194
1195       mi_uiout->field_fmt ("thread-group", "i%d", inferior->num);
1196       mi_uiout->field_core_addr ("addr", target_gdbarch (), memaddr);
1197       mi_uiout->field_fmt ("len", "%s", hex_string (len));
1198
1199       /* Append 'type=code' into notification if MEMADDR falls in the range of
1200          sections contain code.  */
1201       sec = find_pc_section (memaddr);
1202       if (sec != NULL && sec->objfile != NULL)
1203         {
1204           flagword flags = bfd_get_section_flags (sec->objfile->obfd,
1205                                                   sec->the_bfd_section);
1206
1207           if (flags & SEC_CODE)
1208             mi_uiout->field_string ("type", "code");
1209         }
1210
1211       mi_uiout->redirect (NULL);
1212
1213       gdb_flush (mi->event_channel);
1214     }
1215 }
1216
1217 /* Emit an event when the selection context (inferior, thread, frame)
1218    changed.  */
1219
1220 static void
1221 mi_user_selected_context_changed (user_selected_what selection)
1222 {
1223   struct thread_info *tp;
1224
1225   /* Don't send an event if we're responding to an MI command.  */
1226   if (mi_suppress_notification.user_selected_context)
1227     return;
1228
1229   if (inferior_ptid != null_ptid)
1230     tp = inferior_thread ();
1231   else
1232     tp = NULL;
1233
1234   SWITCH_THRU_ALL_UIS ()
1235     {
1236       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
1237       struct ui_out *mi_uiout;
1238
1239       if (mi == NULL)
1240         continue;
1241
1242       mi_uiout = top_level_interpreter ()->interp_ui_out ();
1243
1244       mi_uiout->redirect (mi->event_channel);
1245       ui_out_redirect_pop redirect_popper (mi_uiout);
1246
1247       target_terminal::scoped_restore_terminal_state term_state;
1248       target_terminal::ours_for_output ();
1249
1250       if (selection & USER_SELECTED_INFERIOR)
1251         print_selected_inferior (mi->cli_uiout);
1252
1253       if (tp != NULL
1254           && (selection & (USER_SELECTED_THREAD | USER_SELECTED_FRAME)))
1255         {
1256           print_selected_thread_frame (mi->cli_uiout, selection);
1257
1258           fprintf_unfiltered (mi->event_channel,
1259                               "thread-selected,id=\"%d\"",
1260                               tp->global_num);
1261
1262           if (tp->state != THREAD_RUNNING)
1263             {
1264               if (has_stack_frames ())
1265                 print_stack_frame_to_uiout (mi_uiout, get_selected_frame (NULL),
1266                                             1, SRC_AND_LOC, 1);
1267             }
1268         }
1269
1270       gdb_flush (mi->event_channel);
1271     }
1272 }
1273
1274 static int
1275 report_initial_inferior (struct inferior *inf, void *closure)
1276 {
1277   /* This function is called from mi_interpreter_init, and since
1278      mi_inferior_added assumes that inferior is fully initialized
1279      and top_level_interpreter_data is set, we cannot call
1280      it here.  */
1281   struct mi_interp *mi = (struct mi_interp *) closure;
1282
1283   target_terminal::scoped_restore_terminal_state term_state;
1284   target_terminal::ours_for_output ();
1285
1286   fprintf_unfiltered (mi->event_channel,
1287                       "thread-group-added,id=\"i%d\"",
1288                       inf->num);
1289   gdb_flush (mi->event_channel);
1290
1291   return 0;
1292 }
1293
1294 ui_out *
1295 mi_interp::interp_ui_out ()
1296 {
1297   return this->mi_uiout;
1298 }
1299
1300 /* Do MI-specific logging actions; save raw_stdout, and change all
1301    the consoles to use the supplied ui-file(s).  */
1302
1303 void
1304 mi_interp::set_logging (ui_file_up logfile, bool logging_redirect)
1305 {
1306   struct mi_interp *mi = this;
1307
1308   if (logfile != NULL)
1309     {
1310       mi->saved_raw_stdout = mi->raw_stdout;
1311       mi->raw_stdout = make_logging_output (mi->raw_stdout,
1312                                             std::move (logfile),
1313                                             logging_redirect);
1314
1315     }
1316   else
1317     {
1318       delete mi->raw_stdout;
1319       mi->raw_stdout = mi->saved_raw_stdout;
1320       mi->saved_raw_stdout = NULL;
1321     }
1322
1323   mi->out->set_raw (mi->raw_stdout);
1324   mi->err->set_raw (mi->raw_stdout);
1325   mi->log->set_raw (mi->raw_stdout);
1326   mi->targ->set_raw (mi->raw_stdout);
1327   mi->event_channel->set_raw (mi->raw_stdout);
1328 }
1329
1330 /* Factory for MI interpreters.  */
1331
1332 static struct interp *
1333 mi_interp_factory (const char *name)
1334 {
1335   return new mi_interp (name);
1336 }
1337
1338 void
1339 _initialize_mi_interp (void)
1340 {
1341   /* The various interpreter levels.  */
1342   interp_factory_register (INTERP_MI1, mi_interp_factory);
1343   interp_factory_register (INTERP_MI2, mi_interp_factory);
1344   interp_factory_register (INTERP_MI3, mi_interp_factory);
1345   interp_factory_register (INTERP_MI, mi_interp_factory);
1346
1347   gdb::observers::signal_received.attach (mi_on_signal_received);
1348   gdb::observers::end_stepping_range.attach (mi_on_end_stepping_range);
1349   gdb::observers::signal_exited.attach (mi_on_signal_exited);
1350   gdb::observers::exited.attach (mi_on_exited);
1351   gdb::observers::no_history.attach (mi_on_no_history);
1352   gdb::observers::new_thread.attach (mi_new_thread);
1353   gdb::observers::thread_exit.attach (mi_thread_exit);
1354   gdb::observers::inferior_added.attach (mi_inferior_added);
1355   gdb::observers::inferior_appeared.attach (mi_inferior_appeared);
1356   gdb::observers::inferior_exit.attach (mi_inferior_exit);
1357   gdb::observers::inferior_removed.attach (mi_inferior_removed);
1358   gdb::observers::record_changed.attach (mi_record_changed);
1359   gdb::observers::normal_stop.attach (mi_on_normal_stop);
1360   gdb::observers::target_resumed.attach (mi_on_resume);
1361   gdb::observers::solib_loaded.attach (mi_solib_loaded);
1362   gdb::observers::solib_unloaded.attach (mi_solib_unloaded);
1363   gdb::observers::about_to_proceed.attach (mi_about_to_proceed);
1364   gdb::observers::traceframe_changed.attach (mi_traceframe_changed);
1365   gdb::observers::tsv_created.attach (mi_tsv_created);
1366   gdb::observers::tsv_deleted.attach (mi_tsv_deleted);
1367   gdb::observers::tsv_modified.attach (mi_tsv_modified);
1368   gdb::observers::breakpoint_created.attach (mi_breakpoint_created);
1369   gdb::observers::breakpoint_deleted.attach (mi_breakpoint_deleted);
1370   gdb::observers::breakpoint_modified.attach (mi_breakpoint_modified);
1371   gdb::observers::command_param_changed.attach (mi_command_param_changed);
1372   gdb::observers::memory_changed.attach (mi_memory_changed);
1373   gdb::observers::sync_execution_done.attach (mi_on_sync_execution_done);
1374   gdb::observers::user_selected_context_changed.attach
1375     (mi_user_selected_context_changed);
1376 }