gdb/mi/mi-interp.c

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