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