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         fprintf_unfiltered (
 416           mi->event_channel,
 417           "record-started,thread-group=\"i%d\",method=\"%s\",format=\"%s\"",
 418           inferior->num, method, format);
 419       else
 420         fprintf_unfiltered (
 421           mi->event_channel,
 422           "record-started,thread-group=\"i%d\",method=\"%s\"",
 423           inferior->num, method);
 424     }
 425   else
 426     fprintf_unfiltered (mi->event_channel,
 427                         "record-stopped,thread-group=\"i%d\"", inferior->num);
 428
 429
 430   gdb_flush (mi->event_channel);
 431
 432   do_cleanups (old_chain);
 433 }
 434
 435 static void
 436 mi_inferior_added (struct inferior *inf)
 437 {
 438   struct mi_interp *mi = (struct mi_interp *) top_level_interpreter_data ();
 439   struct cleanup *old_chain;
 440
 441   old_chain = make_cleanup_restore_target_terminal ();
 442   target_terminal_ours_for_output ();
 443
 444   fprintf_unfiltered (mi->event_channel,
 445                       "thread-group-added,id=\"i%d\"",
 446                       inf->num);
 447   gdb_flush (mi->event_channel);
 448
 449   do_cleanups (old_chain);
 450 }
 451
 452 static void
 453 mi_inferior_appeared (struct inferior *inf)
 454 {
 455   struct mi_interp *mi = (struct mi_interp *) top_level_interpreter_data ();
 456   struct cleanup *old_chain;
 457
 458   old_chain = make_cleanup_restore_target_terminal ();
 459   target_terminal_ours_for_output ();
 460
 461   fprintf_unfiltered (mi->event_channel,
 462                       "thread-group-started,id=\"i%d\",pid=\"%d\"",
 463                       inf->num, inf->pid);
 464   gdb_flush (mi->event_channel);
 465
 466   do_cleanups (old_chain);
 467 }
 468
 469 static void
 470 mi_inferior_exit (struct inferior *inf)
 471 {
 472   struct mi_interp *mi = (struct mi_interp *) top_level_interpreter_data ();
 473   struct cleanup *old_chain;
 474
 475   old_chain = make_cleanup_restore_target_terminal ();
 476   target_terminal_ours_for_output ();
 477
 478   if (inf->has_exit_code)
 479     fprintf_unfiltered (mi->event_channel,
 480                         "thread-group-exited,id=\"i%d\",exit-code=\"%s\"",
 481                         inf->num, int_string (inf->exit_code, 8, 0, 0, 1));
 482   else
 483     fprintf_unfiltered (mi->event_channel,
 484                         "thread-group-exited,id=\"i%d\"", inf->num);
 485   gdb_flush (mi->event_channel);
 486
 487   do_cleanups (old_chain);
 488 }
 489
 490 static void
 491 mi_inferior_removed (struct inferior *inf)
 492 {
 493   struct mi_interp *mi = (struct mi_interp *) top_level_interpreter_data ();
 494   struct cleanup *old_chain;
 495
 496   old_chain = make_cleanup_restore_target_terminal ();
 497   target_terminal_ours_for_output ();
 498
 499   fprintf_unfiltered (mi->event_channel,
 500                       "thread-group-removed,id=\"i%d\"",
 501                       inf->num);
 502   gdb_flush (mi->event_channel);
 503
 504   do_cleanups (old_chain);
 505 }
 506
 507 /* Return the MI interpreter, if it is active -- either because it's
 508    the top-level interpreter or the interpreter executing the current
 509    command.  Returns NULL if the MI interpreter is not being used.  */
 510
 511 static struct interp *
 512 find_mi_interpreter (void)
 513 {
 514   struct interp *interp;
 515
 516   interp = top_level_interpreter ();
 517   if (ui_out_is_mi_like_p (interp_ui_out (interp)))
 518     return interp;
 519
 520   interp = command_interp ();
 521   if (ui_out_is_mi_like_p (interp_ui_out (interp)))
 522     return interp;
 523
 524   return NULL;
 525 }
 526
 527 /* Return the MI_INTERP structure of the active MI interpreter.
 528    Returns NULL if MI is not active.  */
 529
 530 static struct mi_interp *
 531 mi_interp_data (void)
 532 {
 533   struct interp *interp = find_mi_interpreter ();
 534
 535   if (interp != NULL)
 536     return (struct mi_interp *) interp_data (interp);
 537   return NULL;
 538 }
 539
 540 /* Observers for several run control events that print why the
 541    inferior has stopped to both the the MI event channel and to the MI
 542    console.  If the MI interpreter is not active, print nothing.  */
 543
 544 /* Observer for the signal_received notification.  */
 545
 546 static void
 547 mi_on_signal_received (enum gdb_signal siggnal)
 548 {
 549   struct mi_interp *mi = mi_interp_data ();
 550
 551   if (mi == NULL)
 552     return;
 553
 554   print_signal_received_reason (mi->mi_uiout, siggnal);
 555   print_signal_received_reason (mi->cli_uiout, siggnal);
 556 }
 557
 558 /* Observer for the end_stepping_range notification.  */
 559
 560 static void
 561 mi_on_end_stepping_range (void)
 562 {
 563   struct mi_interp *mi = mi_interp_data ();
 564
 565   if (mi == NULL)
 566     return;
 567
 568   print_end_stepping_range_reason (mi->mi_uiout);
 569   print_end_stepping_range_reason (mi->cli_uiout);
 570 }
 571
 572 /* Observer for the signal_exited notification.  */
 573
 574 static void
 575 mi_on_signal_exited (enum gdb_signal siggnal)
 576 {
 577   struct mi_interp *mi = mi_interp_data ();
 578
 579   if (mi == NULL)
 580     return;
 581
 582   print_signal_exited_reason (mi->mi_uiout, siggnal);
 583   print_signal_exited_reason (mi->cli_uiout, siggnal);
 584 }
 585
 586 /* Observer for the exited notification.  */
 587
 588 static void
 589 mi_on_exited (int exitstatus)
 590 {
 591   struct mi_interp *mi = mi_interp_data ();
 592
 593   if (mi == NULL)
 594     return;
 595
 596   print_exited_reason (mi->mi_uiout, exitstatus);
 597   print_exited_reason (mi->cli_uiout, exitstatus);
 598 }
 599
 600 /* Observer for the no_history notification.  */
 601
 602 static void
 603 mi_on_no_history (void)
 604 {
 605   struct mi_interp *mi = mi_interp_data ();
 606
 607   if (mi == NULL)
 608     return;
 609
 610   print_no_history_reason (mi->mi_uiout);
 611   print_no_history_reason (mi->cli_uiout);
 612 }
 613
 614 static void
 615 mi_on_normal_stop (struct bpstats *bs, int print_frame)
 616 {
 617   /* Since this can be called when CLI command is executing,
 618      using cli interpreter, be sure to use MI uiout for output,
 619      not the current one.  */
 620   struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
 621
 622   if (print_frame)
 623     {
 624       struct thread_info *tp;
 625       int core;
 626
 627       tp = inferior_thread ();
 628
 629       if (tp->thread_fsm != NULL
 630           && thread_fsm_finished_p (tp->thread_fsm))
 631         {
 632           enum async_reply_reason reason;
 633
 634           reason = thread_fsm_async_reply_reason (tp->thread_fsm);
 635           ui_out_field_string (mi_uiout, "reason",
 636                                async_reason_lookup (reason));
 637         }
 638       print_stop_event (mi_uiout);
 639
 640       /* Breakpoint hits should always be mirrored to the console.
 641          Deciding what to mirror to the console wrt to breakpoints and
 642          random stops gets messy real fast.  E.g., say "s" trips on a
 643          breakpoint.  We'd clearly want to mirror the event to the
 644          console in this case.  But what about more complicated cases
 645          like "s&; thread n; s&", and one of those steps spawning a
 646          new thread, and that thread hitting a breakpoint?  It's
 647          impossible in general to track whether the thread had any
 648          relation to the commands that had been executed.  So we just
 649          simplify and always mirror breakpoints and random events to
 650          the console.
 651
 652          OTOH, we should print the source line to the console when
 653          stepping or other similar commands, iff the step was started
 654          by a console command, but not if it was started with
 655          -exec-step or similar.  */
 656       if ((bpstat_what (tp->control.stop_bpstat).main_action
 657            == BPSTAT_WHAT_STOP_NOISY)
 658           || !(tp->thread_fsm != NULL
 659                && thread_fsm_finished_p (tp->thread_fsm))
 660           || (tp->control.command_interp != NULL
 661               && tp->control.command_interp != top_level_interpreter ()))
 662         {
 663           struct mi_interp *mi
 664             = (struct mi_interp *) top_level_interpreter_data ();
 665
 666           print_stop_event (mi->cli_uiout);
 667         }
 668
 669       tp = inferior_thread ();
 670       ui_out_field_int (mi_uiout, "thread-id", tp->global_num);
 671       if (non_stop)
 672         {
 673           struct cleanup *back_to = make_cleanup_ui_out_list_begin_end
 674             (mi_uiout, "stopped-threads");
 675
 676           ui_out_field_int (mi_uiout, NULL, tp->global_num);
 677           do_cleanups (back_to);
 678         }
 679       else
 680         ui_out_field_string (mi_uiout, "stopped-threads", "all");
 681
 682       core = target_core_of_thread (inferior_ptid);
 683       if (core != -1)
 684         ui_out_field_int (mi_uiout, "core", core);
 685     }
 686
 687   fputs_unfiltered ("*stopped", raw_stdout);
 688   mi_out_put (mi_uiout, raw_stdout);
 689   mi_out_rewind (mi_uiout);
 690   mi_print_timing_maybe ();
 691   fputs_unfiltered ("\n", raw_stdout);
 692   gdb_flush (raw_stdout);
 693 }
 694
 695 static void
 696 mi_about_to_proceed (void)
 697 {
 698   /* Suppress output while calling an inferior function.  */
 699
 700   if (!ptid_equal (inferior_ptid, null_ptid))
 701     {
 702       struct thread_info *tp = inferior_thread ();
 703
 704       if (tp->control.in_infcall)
 705         return;
 706     }
 707
 708   mi_proceeded = 1;
 709 }
 710
 711 /* When the element is non-zero, no MI notifications will be emitted in
 712    response to the corresponding observers.  */
 713
 714 struct mi_suppress_notification mi_suppress_notification =
 715   {
 716     0,
 717     0,
 718     0,
 719   };
 720
 721 /* Emit notification on changing a traceframe.  */
 722
 723 static void
 724 mi_traceframe_changed (int tfnum, int tpnum)
 725 {
 726   struct mi_interp *mi = (struct mi_interp *) top_level_interpreter_data ();
 727   struct cleanup *old_chain;
 728
 729   if (mi_suppress_notification.traceframe)
 730     return;
 731
 732   old_chain = make_cleanup_restore_target_terminal ();
 733   target_terminal_ours_for_output ();
 734
 735   if (tfnum >= 0)
 736     fprintf_unfiltered (mi->event_channel, "traceframe-changed,"
 737                         "num=\"%d\",tracepoint=\"%d\"\n",
 738                         tfnum, tpnum);
 739   else
 740     fprintf_unfiltered (mi->event_channel, "traceframe-changed,end");
 741
 742   gdb_flush (mi->event_channel);
 743
 744   do_cleanups (old_chain);
 745 }
 746
 747 /* Emit notification on creating a trace state variable.  */
 748
 749 static void
 750 mi_tsv_created (const struct trace_state_variable *tsv)
 751 {
 752   struct mi_interp *mi = (struct mi_interp *) top_level_interpreter_data ();
 753   struct cleanup *old_chain;
 754
 755   old_chain = make_cleanup_restore_target_terminal ();
 756   target_terminal_ours_for_output ();
 757
 758   fprintf_unfiltered (mi->event_channel, "tsv-created,"
 759                       "name=\"%s\",initial=\"%s\"\n",
 760                       tsv->name, plongest (tsv->initial_value));
 761
 762   gdb_flush (mi->event_channel);
 763
 764   do_cleanups (old_chain);
 765 }
 766
 767 /* Emit notification on deleting a trace state variable.  */
 768
 769 static void
 770 mi_tsv_deleted (const struct trace_state_variable *tsv)
 771 {
 772   struct mi_interp *mi = (struct mi_interp *) top_level_interpreter_data ();
 773   struct cleanup *old_chain;
 774
 775   old_chain = make_cleanup_restore_target_terminal ();
 776   target_terminal_ours_for_output ();
 777
 778   if (tsv != NULL)
 779     fprintf_unfiltered (mi->event_channel, "tsv-deleted,"
 780                         "name=\"%s\"\n", tsv->name);
 781   else
 782     fprintf_unfiltered (mi->event_channel, "tsv-deleted\n");
 783
 784   gdb_flush (mi->event_channel);
 785
 786   do_cleanups (old_chain);
 787 }
 788
 789 /* Emit notification on modifying a trace state variable.  */
 790
 791 static void
 792 mi_tsv_modified (const struct trace_state_variable *tsv)
 793 {
 794   struct mi_interp *mi = (struct mi_interp *) top_level_interpreter_data ();
 795   struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
 796   struct cleanup *old_chain;
 797
 798   old_chain = make_cleanup_restore_target_terminal ();
 799   target_terminal_ours_for_output ();
 800
 801   fprintf_unfiltered (mi->event_channel,
 802                       "tsv-modified");
 803
 804   ui_out_redirect (mi_uiout, mi->event_channel);
 805
 806   ui_out_field_string (mi_uiout, "name", tsv->name);
 807   ui_out_field_string (mi_uiout, "initial",
 808                        plongest (tsv->initial_value));
 809   if (tsv->value_known)
 810     ui_out_field_string (mi_uiout, "current", plongest (tsv->value));
 811
 812   ui_out_redirect (mi_uiout, NULL);
 813
 814   gdb_flush (mi->event_channel);
 815
 816   do_cleanups (old_chain);
 817 }
 818
 819 /* Emit notification about a created breakpoint.  */
 820
 821 static void
 822 mi_breakpoint_created (struct breakpoint *b)
 823 {
 824   struct mi_interp *mi = (struct mi_interp *) top_level_interpreter_data ();
 825   struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
 826   struct cleanup *old_chain;
 827
 828   if (mi_suppress_notification.breakpoint)
 829     return;
 830
 831   if (b->number <= 0)
 832     return;
 833
 834   old_chain = make_cleanup_restore_target_terminal ();
 835   target_terminal_ours_for_output ();
 836
 837   fprintf_unfiltered (mi->event_channel,
 838                       "breakpoint-created");
 839   /* We want the output from gdb_breakpoint_query to go to
 840      mi->event_channel.  One approach would be to just call
 841      gdb_breakpoint_query, and then use mi_out_put to send the current
 842      content of mi_outout into mi->event_channel.  However, that will
 843      break if anything is output to mi_uiout prior to calling the
 844      breakpoint_created notifications.  So, we use
 845      ui_out_redirect.  */
 846   ui_out_redirect (mi_uiout, mi->event_channel);
 847   TRY
 848     {
 849       gdb_breakpoint_query (mi_uiout, b->number, NULL);
 850     }
 851   CATCH (e, RETURN_MASK_ERROR)
 852     {
 853     }
 854   END_CATCH
 855
 856   ui_out_redirect (mi_uiout, NULL);
 857
 858   gdb_flush (mi->event_channel);
 859
 860   do_cleanups (old_chain);
 861 }
 862
 863 /* Emit notification about deleted breakpoint.  */
 864
 865 static void
 866 mi_breakpoint_deleted (struct breakpoint *b)
 867 {
 868   struct mi_interp *mi = (struct mi_interp *) top_level_interpreter_data ();
 869   struct cleanup *old_chain;
 870
 871   if (mi_suppress_notification.breakpoint)
 872     return;
 873
 874   if (b->number <= 0)
 875     return;
 876
 877   old_chain = make_cleanup_restore_target_terminal ();
 878   target_terminal_ours_for_output ();
 879
 880   fprintf_unfiltered (mi->event_channel, "breakpoint-deleted,id=\"%d\"",
 881                       b->number);
 882
 883   gdb_flush (mi->event_channel);
 884
 885   do_cleanups (old_chain);
 886 }
 887
 888 /* Emit notification about modified breakpoint.  */
 889
 890 static void
 891 mi_breakpoint_modified (struct breakpoint *b)
 892 {
 893   struct mi_interp *mi = (struct mi_interp *) top_level_interpreter_data ();
 894   struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
 895   struct cleanup *old_chain;
 896
 897   if (mi_suppress_notification.breakpoint)
 898     return;
 899
 900   if (b->number <= 0)
 901     return;
 902
 903   old_chain = make_cleanup_restore_target_terminal ();
 904   target_terminal_ours_for_output ();
 905
 906   fprintf_unfiltered (mi->event_channel,
 907                       "breakpoint-modified");
 908   /* We want the output from gdb_breakpoint_query to go to
 909      mi->event_channel.  One approach would be to just call
 910      gdb_breakpoint_query, and then use mi_out_put to send the current
 911      content of mi_outout into mi->event_channel.  However, that will
 912      break if anything is output to mi_uiout prior to calling the
 913      breakpoint_created notifications.  So, we use
 914      ui_out_redirect.  */
 915   ui_out_redirect (mi_uiout, mi->event_channel);
 916   TRY
 917     {
 918       gdb_breakpoint_query (mi_uiout, b->number, NULL);
 919     }
 920   CATCH (e, RETURN_MASK_ERROR)
 921     {
 922     }
 923   END_CATCH
 924
 925   ui_out_redirect (mi_uiout, NULL);
 926
 927   gdb_flush (mi->event_channel);
 928
 929   do_cleanups (old_chain);
 930 }
 931
 932 static int
 933 mi_output_running_pid (struct thread_info *info, void *arg)
 934 {
 935   ptid_t *ptid = (ptid_t *) arg;
 936
 937   if (ptid_get_pid (*ptid) == ptid_get_pid (info->ptid))
 938     fprintf_unfiltered (raw_stdout,
 939                         "*running,thread-id=\"%d\"\n",
 940                         info->global_num);
 941
 942   return 0;
 943 }
 944
 945 static int
 946 mi_inferior_count (struct inferior *inf, void *arg)
 947 {
 948   if (inf->pid != 0)
 949     {
 950       int *count_p = (int *) arg;
 951       (*count_p)++;
 952     }
 953
 954   return 0;
 955 }
 956
 957 static void
 958 mi_on_resume (ptid_t ptid)
 959 {
 960   struct thread_info *tp = NULL;
 961
 962   if (ptid_equal (ptid, minus_one_ptid) || ptid_is_pid (ptid))
 963     tp = inferior_thread ();
 964   else
 965     tp = find_thread_ptid (ptid);
 966
 967   /* Suppress output while calling an inferior function.  */
 968   if (tp->control.in_infcall)
 969     return;
 970
 971   /* To cater for older frontends, emit ^running, but do it only once
 972      per each command.  We do it here, since at this point we know
 973      that the target was successfully resumed, and in non-async mode,
 974      we won't return back to MI interpreter code until the target
 975      is done running, so delaying the output of "^running" until then
 976      will make it impossible for frontend to know what's going on.
 977
 978      In future (MI3), we'll be outputting "^done" here.  */
 979   if (!running_result_record_printed && mi_proceeded)
 980     {
 981       fprintf_unfiltered (raw_stdout, "%s^running\n",
 982                           current_token ? current_token : "");
 983     }
 984
 985   if (ptid_get_pid (ptid) == -1)
 986     fprintf_unfiltered (raw_stdout, "*running,thread-id=\"all\"\n");
 987   else if (ptid_is_pid (ptid))
 988     {
 989       int count = 0;
 990
 991       /* Backwards compatibility.  If there's only one inferior,
 992          output "all", otherwise, output each resumed thread
 993          individually.  */
 994       iterate_over_inferiors (mi_inferior_count, &count);
 995
 996       if (count == 1)
 997         fprintf_unfiltered (raw_stdout, "*running,thread-id=\"all\"\n");
 998       else
 999         iterate_over_threads (mi_output_running_pid, &ptid);
1000     }
1001   else
1002     {
1003       struct thread_info *ti = find_thread_ptid (ptid);
1004
1005       gdb_assert (ti);
1006       fprintf_unfiltered (raw_stdout, "*running,thread-id=\"%d\"\n",
1007                           ti->global_num);
1008     }
1009
1010   if (!running_result_record_printed && mi_proceeded)
1011     {
1012       running_result_record_printed = 1;
1013       /* This is what gdb used to do historically -- printing prompt even if
1014          it cannot actually accept any input.  This will be surely removed
1015          for MI3, and may be removed even earlier.  SYNC_EXECUTION is
1016          checked here because we only need to emit a prompt if a
1017          synchronous command was issued when the target is async.  */
1018       if (!target_can_async_p () || sync_execution)
1019         fputs_unfiltered ("(gdb) \n", raw_stdout);
1020     }
1021   gdb_flush (raw_stdout);
1022 }
1023
1024 static void
1025 mi_solib_loaded (struct so_list *solib)
1026 {
1027   struct mi_interp *mi = (struct mi_interp *) top_level_interpreter_data ();
1028   struct ui_out *uiout = interp_ui_out (top_level_interpreter ());
1029   struct cleanup *old_chain;
1030
1031   old_chain = make_cleanup_restore_target_terminal ();
1032   target_terminal_ours_for_output ();
1033
1034   fprintf_unfiltered (mi->event_channel, "library-loaded");
1035
1036   ui_out_redirect (uiout, mi->event_channel);
1037
1038   ui_out_field_string (uiout, "id", solib->so_original_name);
1039   ui_out_field_string (uiout, "target-name", solib->so_original_name);
1040   ui_out_field_string (uiout, "host-name", solib->so_name);
1041   ui_out_field_int (uiout, "symbols-loaded", solib->symbols_loaded);
1042   if (!gdbarch_has_global_solist (target_gdbarch ()))
1043     {
1044       ui_out_field_fmt (uiout, "thread-group", "i%d",
1045                         current_inferior ()->num);
1046     }
1047
1048   ui_out_redirect (uiout, NULL);
1049
1050   gdb_flush (mi->event_channel);
1051
1052   do_cleanups (old_chain);
1053 }
1054
1055 static void
1056 mi_solib_unloaded (struct so_list *solib)
1057 {
1058   struct mi_interp *mi = (struct mi_interp *) top_level_interpreter_data ();
1059   struct ui_out *uiout = interp_ui_out (top_level_interpreter ());
1060   struct cleanup *old_chain;
1061
1062   old_chain = make_cleanup_restore_target_terminal ();
1063   target_terminal_ours_for_output ();
1064
1065   fprintf_unfiltered (mi->event_channel, "library-unloaded");
1066
1067   ui_out_redirect (uiout, mi->event_channel);
1068
1069   ui_out_field_string (uiout, "id", solib->so_original_name);
1070   ui_out_field_string (uiout, "target-name", solib->so_original_name);
1071   ui_out_field_string (uiout, "host-name", solib->so_name);
1072   if (!gdbarch_has_global_solist (target_gdbarch ()))
1073     {
1074       ui_out_field_fmt (uiout, "thread-group", "i%d",
1075                         current_inferior ()->num);
1076     }
1077
1078   ui_out_redirect (uiout, NULL);
1079
1080   gdb_flush (mi->event_channel);
1081
1082   do_cleanups (old_chain);
1083 }
1084
1085 /* Emit notification about the command parameter change.  */
1086
1087 static void
1088 mi_command_param_changed (const char *param, const char *value)
1089 {
1090   struct mi_interp *mi = (struct mi_interp *) top_level_interpreter_data ();
1091   struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
1092   struct cleanup *old_chain;
1093
1094   if (mi_suppress_notification.cmd_param_changed)
1095     return;
1096
1097   old_chain = make_cleanup_restore_target_terminal ();
1098   target_terminal_ours_for_output ();
1099
1100   fprintf_unfiltered (mi->event_channel,
1101                       "cmd-param-changed");
1102
1103   ui_out_redirect (mi_uiout, mi->event_channel);
1104
1105   ui_out_field_string (mi_uiout, "param", param);
1106   ui_out_field_string (mi_uiout, "value", value);
1107
1108   ui_out_redirect (mi_uiout, NULL);
1109
1110   gdb_flush (mi->event_channel);
1111
1112   do_cleanups (old_chain);
1113 }
1114
1115 /* Emit notification about the target memory change.  */
1116
1117 static void
1118 mi_memory_changed (struct inferior *inferior, CORE_ADDR memaddr,
1119                    ssize_t len, const bfd_byte *myaddr)
1120 {
1121   struct mi_interp *mi = (struct mi_interp *) top_level_interpreter_data ();
1122   struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
1123   struct obj_section *sec;
1124   struct cleanup *old_chain;
1125
1126   if (mi_suppress_notification.memory)
1127     return;
1128
1129   old_chain = make_cleanup_restore_target_terminal ();
1130   target_terminal_ours_for_output ();
1131
1132   fprintf_unfiltered (mi->event_channel,
1133                       "memory-changed");
1134
1135   ui_out_redirect (mi_uiout, mi->event_channel);
1136
1137   ui_out_field_fmt (mi_uiout, "thread-group", "i%d", inferior->num);
1138   ui_out_field_core_addr (mi_uiout, "addr", target_gdbarch (), memaddr);
1139   ui_out_field_fmt (mi_uiout, "len", "%s", hex_string (len));
1140
1141   /* Append 'type=code' into notification if MEMADDR falls in the range of
1142      sections contain code.  */
1143   sec = find_pc_section (memaddr);
1144   if (sec != NULL && sec->objfile != NULL)
1145     {
1146       flagword flags = bfd_get_section_flags (sec->objfile->obfd,
1147                                               sec->the_bfd_section);
1148
1149       if (flags & SEC_CODE)
1150         ui_out_field_string (mi_uiout, "type", "code");
1151     }
1152
1153   ui_out_redirect (mi_uiout, NULL);
1154
1155   gdb_flush (mi->event_channel);
1156
1157   do_cleanups (old_chain);
1158 }
1159
1160 static int
1161 report_initial_inferior (struct inferior *inf, void *closure)
1162 {
1163   /* This function is called from mi_intepreter_init, and since
1164      mi_inferior_added assumes that inferior is fully initialized
1165      and top_level_interpreter_data is set, we cannot call
1166      it here.  */
1167   struct mi_interp *mi = (struct mi_interp *) closure;
1168   struct cleanup *old_chain;
1169
1170   old_chain = make_cleanup_restore_target_terminal ();
1171   target_terminal_ours_for_output ();
1172
1173   fprintf_unfiltered (mi->event_channel,
1174                       "thread-group-added,id=\"i%d\"",
1175                       inf->num);
1176   gdb_flush (mi->event_channel);
1177
1178   do_cleanups (old_chain);
1179   return 0;
1180 }
1181
1182 static struct ui_out *
1183 mi_ui_out (struct interp *interp)
1184 {
1185   struct mi_interp *mi = (struct mi_interp *) interp_data (interp);
1186
1187   return mi->mi_uiout;
1188 }
1189
1190 /* Save the original value of raw_stdout here when logging, so we can
1191    restore correctly when done.  */
1192
1193 static struct ui_file *saved_raw_stdout;
1194
1195 /* Do MI-specific logging actions; save raw_stdout, and change all
1196    the consoles to use the supplied ui-file(s).  */
1197
1198 static int
1199 mi_set_logging (struct interp *interp, int start_log,
1200                 struct ui_file *out, struct ui_file *logfile)
1201 {
1202   struct mi_interp *mi = (struct mi_interp *) interp_data (interp);
1203
1204   if (!mi)
1205     return 0;
1206
1207   if (start_log)
1208     {
1209       /* The tee created already is based on gdb_stdout, which for MI
1210          is a console and so we end up in an infinite loop of console
1211          writing to ui_file writing to console etc.  So discard the
1212          existing tee (it hasn't been used yet, and MI won't ever use
1213          it), and create one based on raw_stdout instead.  */
1214       if (logfile)
1215         {
1216           ui_file_delete (out);
1217           out = tee_file_new (raw_stdout, 0, logfile, 0);
1218         }
1219
1220       saved_raw_stdout = raw_stdout;
1221       raw_stdout = out;
1222     }
1223   else
1224     {
1225       raw_stdout = saved_raw_stdout;
1226       saved_raw_stdout = NULL;
1227     }
1228
1229   mi_console_set_raw (mi->out, raw_stdout);
1230   mi_console_set_raw (mi->err, raw_stdout);
1231   mi_console_set_raw (mi->log, raw_stdout);
1232   mi_console_set_raw (mi->targ, raw_stdout);
1233   mi_console_set_raw (mi->event_channel, raw_stdout);
1234
1235   return 1;
1236 }
1237
1238 extern initialize_file_ftype _initialize_mi_interp; /* -Wmissing-prototypes */
1239
1240 void
1241 _initialize_mi_interp (void)
1242 {
1243   static const struct interp_procs procs =
1244     {
1245       mi_interpreter_init,      /* init_proc */
1246       mi_interpreter_resume,    /* resume_proc */
1247       mi_interpreter_suspend,   /* suspend_proc */
1248       mi_interpreter_exec,      /* exec_proc */
1249       mi_ui_out,                /* ui_out_proc */
1250       mi_set_logging,           /* set_logging_proc */
1251       mi_command_loop           /* command_loop_proc */
1252     };
1253
1254   /* The various interpreter levels.  */
1255   interp_add (interp_new (INTERP_MI1, &procs));
1256   interp_add (interp_new (INTERP_MI2, &procs));
1257   interp_add (interp_new (INTERP_MI3, &procs));
1258   interp_add (interp_new (INTERP_MI, &procs));
1259 }