gdb/mi/mi-interp.c

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