gdb/mi/mi-interp.c

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