gdb/mi/mi-interp.c

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