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