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