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