gdb/mi/mi-interp.c

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