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