gdb/mi/mi-interp.c

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