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