gdb/mi/mi-interp.c

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