gdb/mi/mi-interp.c

   1 /* MI Interpreter Definitions and Commands for GDB, the GNU debugger.
   2
   3    Copyright (C) 2002-2013 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
  41 /* These are the interpreter setup, etc. functions for the MI
  42    interpreter.  */
  43
  44 static void mi_execute_command_wrapper (const char *cmd);
  45 static void mi_execute_command_input_handler (char *cmd);
  46 static void mi_command_loop (void *data);
  47
  48 /* These are hooks that we put in place while doing interpreter_exec
  49    so we can report interesting things that happened "behind the MI's
  50    back" in this command.  */
  51
  52 static int mi_interp_query_hook (const char *ctlstr, va_list ap)
  53   ATTRIBUTE_PRINTF (1, 0);
  54
  55 static void mi_insert_notify_hooks (void);
  56 static void mi_remove_notify_hooks (void);
  57 static void mi_on_normal_stop (struct bpstats *bs, int print_frame);
  58
  59 static void mi_new_thread (struct thread_info *t);
  60 static void mi_thread_exit (struct thread_info *t, int silent);
  61 static void mi_record_changed (struct inferior*, int);
  62 static void mi_inferior_added (struct inferior *inf);
  63 static void mi_inferior_appeared (struct inferior *inf);
  64 static void mi_inferior_exit (struct inferior *inf);
  65 static void mi_inferior_removed (struct inferior *inf);
  66 static void mi_on_resume (ptid_t ptid);
  67 static void mi_solib_loaded (struct so_list *solib);
  68 static void mi_solib_unloaded (struct so_list *solib);
  69 static void mi_about_to_proceed (void);
  70 static void mi_traceframe_changed (int tfnum, int tpnum);
  71 static void mi_tsv_created (const struct trace_state_variable *tsv);
  72 static void mi_tsv_deleted (const struct trace_state_variable *tsv);
  73 static void mi_tsv_modified (const struct trace_state_variable *tsv);
  74 static void mi_breakpoint_created (struct breakpoint *b);
  75 static void mi_breakpoint_deleted (struct breakpoint *b);
  76 static void mi_breakpoint_modified (struct breakpoint *b);
  77 static void mi_command_param_changed (const char *param, const char *value);
  78 static void mi_memory_changed (struct inferior *inf, CORE_ADDR memaddr,
  79                                ssize_t len, const bfd_byte *myaddr);
  80
  81 static int report_initial_inferior (struct inferior *inf, void *closure);
  82
  83 static void *
  84 mi_interpreter_init (struct interp *interp, int top_level)
  85 {
  86   struct mi_interp *mi = XMALLOC (struct mi_interp);
  87   const char *name;
  88   int mi_version;
  89
  90   /* Assign the output channel created at startup to its own global,
  91      so that we can create a console channel that encapsulates and
  92      prefixes all gdb_output-type bits coming from the rest of the
  93      debugger.  */
  94
  95   raw_stdout = gdb_stdout;
  96
  97   /* Create MI console channels, each with a different prefix so they
  98      can be distinguished.  */
  99   mi->out = mi_console_file_new (raw_stdout, "~", '"');
 100   mi->err = mi_console_file_new (raw_stdout, "&", '"');
 101   mi->log = mi->err;
 102   mi->targ = mi_console_file_new (raw_stdout, "@", '"');
 103   mi->event_channel = mi_console_file_new (raw_stdout, "=", 0);
 104
 105   name = interp_name (interp);
 106   /* INTERP_MI selects the most recent released version.  "mi2" was
 107      released as part of GDB 6.0.  */
 108   if (strcmp (name, INTERP_MI) == 0)
 109     mi_version = 2;
 110   else if (strcmp (name, INTERP_MI1) == 0)
 111     mi_version = 1;
 112   else if (strcmp (name, INTERP_MI2) == 0)
 113     mi_version = 2;
 114   else if (strcmp (name, INTERP_MI3) == 0)
 115     mi_version = 3;
 116   else
 117     gdb_assert_not_reached ("unhandled MI version");
 118
 119   mi->uiout = mi_out_new (mi_version);
 120
 121   if (top_level)
 122     {
 123       observer_attach_new_thread (mi_new_thread);
 124       observer_attach_thread_exit (mi_thread_exit);
 125       observer_attach_inferior_added (mi_inferior_added);
 126       observer_attach_inferior_appeared (mi_inferior_appeared);
 127       observer_attach_inferior_exit (mi_inferior_exit);
 128       observer_attach_inferior_removed (mi_inferior_removed);
 129       observer_attach_record_changed (mi_record_changed);
 130       observer_attach_normal_stop (mi_on_normal_stop);
 131       observer_attach_target_resumed (mi_on_resume);
 132       observer_attach_solib_loaded (mi_solib_loaded);
 133       observer_attach_solib_unloaded (mi_solib_unloaded);
 134       observer_attach_about_to_proceed (mi_about_to_proceed);
 135       observer_attach_traceframe_changed (mi_traceframe_changed);
 136       observer_attach_tsv_created (mi_tsv_created);
 137       observer_attach_tsv_deleted (mi_tsv_deleted);
 138       observer_attach_tsv_modified (mi_tsv_modified);
 139       observer_attach_breakpoint_created (mi_breakpoint_created);
 140       observer_attach_breakpoint_deleted (mi_breakpoint_deleted);
 141       observer_attach_breakpoint_modified (mi_breakpoint_modified);
 142       observer_attach_command_param_changed (mi_command_param_changed);
 143       observer_attach_memory_changed (mi_memory_changed);
 144
 145       /* The initial inferior is created before this function is
 146          called, so we need to report it explicitly.  Use iteration in
 147          case future version of GDB creates more than one inferior
 148          up-front.  */
 149       iterate_over_inferiors (report_initial_inferior, mi);
 150     }
 151
 152   return mi;
 153 }
 154
 155 static int
 156 mi_interpreter_resume (void *data)
 157 {
 158   struct mi_interp *mi = data;
 159
 160   /* As per hack note in mi_interpreter_init, swap in the output
 161      channels... */
 162   gdb_setup_readline ();
 163
 164   /* These overwrite some of the initialization done in
 165      _intialize_event_loop.  */
 166   call_readline = gdb_readline2;
 167   input_handler = mi_execute_command_input_handler;
 168   async_command_editing_p = 0;
 169   /* FIXME: This is a total hack for now.  PB's use of the MI
 170      implicitly relies on a bug in the async support which allows
 171      asynchronous commands to leak through the commmand loop.  The bug
 172      involves (but is not limited to) the fact that sync_execution was
 173      erroneously initialized to 0.  Duplicate by initializing it thus
 174      here...  */
 175   sync_execution = 0;
 176
 177   gdb_stdout = mi->out;
 178   /* Route error and log output through the MI.  */
 179   gdb_stderr = mi->err;
 180   gdb_stdlog = mi->log;
 181   /* Route target output through the MI.  */
 182   gdb_stdtarg = mi->targ;
 183   /* Route target error through the MI as well.  */
 184   gdb_stdtargerr = mi->targ;
 185
 186   /* Replace all the hooks that we know about.  There really needs to
 187      be a better way of doing this... */
 188   clear_interpreter_hooks ();
 189
 190   deprecated_show_load_progress = mi_load_progress;
 191
 192   return 1;
 193 }
 194
 195 static int
 196 mi_interpreter_suspend (void *data)
 197 {
 198   gdb_disable_readline ();
 199   return 1;
 200 }
 201
 202 static struct gdb_exception
 203 mi_interpreter_exec (void *data, const char *command)
 204 {
 205   mi_execute_command_wrapper (command);
 206   return exception_none;
 207 }
 208
 209 /* Never display the default GDB prompt in MI case.  */
 210
 211 static int
 212 mi_interpreter_prompt_p (void *data)
 213 {
 214   return 0;
 215 }
 216
 217 void
 218 mi_cmd_interpreter_exec (char *command, char **argv, int argc)
 219 {
 220   struct interp *interp_to_use;
 221   int i;
 222   char *mi_error_message = NULL;
 223   struct cleanup *old_chain;
 224
 225   if (argc < 2)
 226     error (_("-interpreter-exec: "
 227              "Usage: -interpreter-exec interp command"));
 228
 229   interp_to_use = interp_lookup (argv[0]);
 230   if (interp_to_use == NULL)
 231     error (_("-interpreter-exec: could not find interpreter \"%s\""),
 232            argv[0]);
 233
 234   if (!interp_exec_p (interp_to_use))
 235     error (_("-interpreter-exec: interpreter \"%s\" "
 236              "does not support command execution"),
 237               argv[0]);
 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 static void
 424 mi_on_normal_stop (struct bpstats *bs, int print_frame)
 425 {
 426   /* Since this can be called when CLI command is executing,
 427      using cli interpreter, be sure to use MI uiout for output,
 428      not the current one.  */
 429   struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
 430
 431   if (print_frame)
 432     {
 433       int core;
 434
 435       if (current_uiout != mi_uiout)
 436         {
 437           /* The normal_stop function has printed frame information
 438              into CLI uiout, or some other non-MI uiout.  There's no
 439              way we can extract proper fields from random uiout
 440              object, so we print the frame again.  In practice, this
 441              can only happen when running a CLI command in MI.  */
 442           struct ui_out *saved_uiout = current_uiout;
 443           struct target_waitstatus last;
 444           ptid_t last_ptid;
 445
 446           current_uiout = mi_uiout;
 447
 448           get_last_target_status (&last_ptid, &last);
 449           bpstat_print (bs, last.kind);
 450
 451           print_stack_frame (get_selected_frame (NULL), 0, SRC_AND_LOC, 1);
 452           current_uiout = saved_uiout;
 453         }
 454
 455       ui_out_field_int (mi_uiout, "thread-id",
 456                         pid_to_thread_id (inferior_ptid));
 457       if (non_stop)
 458         {
 459           struct cleanup *back_to = make_cleanup_ui_out_list_begin_end
 460             (mi_uiout, "stopped-threads");
 461
 462           ui_out_field_int (mi_uiout, NULL,
 463                             pid_to_thread_id (inferior_ptid));
 464           do_cleanups (back_to);
 465         }
 466       else
 467         ui_out_field_string (mi_uiout, "stopped-threads", "all");
 468
 469       core = target_core_of_thread (inferior_ptid);
 470       if (core != -1)
 471         ui_out_field_int (mi_uiout, "core", core);
 472     }
 473
 474   fputs_unfiltered ("*stopped", raw_stdout);
 475   mi_out_put (mi_uiout, raw_stdout);
 476   mi_out_rewind (mi_uiout);
 477   mi_print_timing_maybe ();
 478   fputs_unfiltered ("\n", raw_stdout);
 479   gdb_flush (raw_stdout);
 480 }
 481
 482 static void
 483 mi_about_to_proceed (void)
 484 {
 485   /* Suppress output while calling an inferior function.  */
 486
 487   if (!ptid_equal (inferior_ptid, null_ptid))
 488     {
 489       struct thread_info *tp = inferior_thread ();
 490
 491       if (tp->control.in_infcall)
 492         return;
 493     }
 494
 495   mi_proceeded = 1;
 496 }
 497
 498 /* When the element is non-zero, no MI notifications will be emitted in
 499    response to the corresponding observers.  */
 500
 501 struct mi_suppress_notification mi_suppress_notification =
 502   {
 503     0,
 504     0,
 505     0,
 506   };
 507
 508 /* Emit notification on changing a traceframe.  */
 509
 510 static void
 511 mi_traceframe_changed (int tfnum, int tpnum)
 512 {
 513   struct mi_interp *mi = top_level_interpreter_data ();
 514
 515   if (mi_suppress_notification.traceframe)
 516     return;
 517
 518   target_terminal_ours ();
 519
 520   if (tfnum >= 0)
 521     fprintf_unfiltered (mi->event_channel, "traceframe-changed,"
 522                         "num=\"%d\",tracepoint=\"%d\"\n",
 523                         tfnum, tpnum);
 524   else
 525     fprintf_unfiltered (mi->event_channel, "traceframe-changed,end");
 526
 527   gdb_flush (mi->event_channel);
 528 }
 529
 530 /* Emit notification on creating a trace state variable.  */
 531
 532 static void
 533 mi_tsv_created (const struct trace_state_variable *tsv)
 534 {
 535   struct mi_interp *mi = top_level_interpreter_data ();
 536
 537   target_terminal_ours ();
 538
 539   fprintf_unfiltered (mi->event_channel, "tsv-created,"
 540                       "name=\"%s\",initial=\"%s\"\n",
 541                       tsv->name, plongest (tsv->initial_value));
 542
 543   gdb_flush (mi->event_channel);
 544 }
 545
 546 /* Emit notification on deleting a trace state variable.  */
 547
 548 static void
 549 mi_tsv_deleted (const struct trace_state_variable *tsv)
 550 {
 551   struct mi_interp *mi = top_level_interpreter_data ();
 552
 553   target_terminal_ours ();
 554
 555   if (tsv != NULL)
 556     fprintf_unfiltered (mi->event_channel, "tsv-deleted,"
 557                         "name=\"%s\"\n", tsv->name);
 558   else
 559     fprintf_unfiltered (mi->event_channel, "tsv-deleted\n");
 560
 561   gdb_flush (mi->event_channel);
 562 }
 563
 564 /* Emit notification on modifying a trace state variable.  */
 565
 566 static void
 567 mi_tsv_modified (const struct trace_state_variable *tsv)
 568 {
 569   struct mi_interp *mi = top_level_interpreter_data ();
 570   struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
 571
 572   target_terminal_ours ();
 573
 574   fprintf_unfiltered (mi->event_channel,
 575                       "tsv-modified");
 576
 577   ui_out_redirect (mi_uiout, mi->event_channel);
 578
 579   ui_out_field_string (mi_uiout, "name", tsv->name);
 580   ui_out_field_string (mi_uiout, "initial",
 581                        plongest (tsv->initial_value));
 582   if (tsv->value_known)
 583     ui_out_field_string (mi_uiout, "current", plongest (tsv->value));
 584
 585   ui_out_redirect (mi_uiout, NULL);
 586
 587   gdb_flush (mi->event_channel);
 588 }
 589
 590 /* Emit notification about a created breakpoint.  */
 591
 592 static void
 593 mi_breakpoint_created (struct breakpoint *b)
 594 {
 595   struct mi_interp *mi = top_level_interpreter_data ();
 596   struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
 597   volatile struct gdb_exception e;
 598
 599   if (mi_suppress_notification.breakpoint)
 600     return;
 601
 602   if (b->number <= 0)
 603     return;
 604
 605   target_terminal_ours ();
 606   fprintf_unfiltered (mi->event_channel,
 607                       "breakpoint-created");
 608   /* We want the output from gdb_breakpoint_query to go to
 609      mi->event_channel.  One approach would be to just call
 610      gdb_breakpoint_query, and then use mi_out_put to send the current
 611      content of mi_outout into mi->event_channel.  However, that will
 612      break if anything is output to mi_uiout prior to calling the
 613      breakpoint_created notifications.  So, we use
 614      ui_out_redirect.  */
 615   ui_out_redirect (mi_uiout, mi->event_channel);
 616   TRY_CATCH (e, RETURN_MASK_ERROR)
 617     gdb_breakpoint_query (mi_uiout, b->number, NULL);
 618   ui_out_redirect (mi_uiout, NULL);
 619
 620   gdb_flush (mi->event_channel);
 621 }
 622
 623 /* Emit notification about deleted breakpoint.  */
 624
 625 static void
 626 mi_breakpoint_deleted (struct breakpoint *b)
 627 {
 628   struct mi_interp *mi = top_level_interpreter_data ();
 629
 630   if (mi_suppress_notification.breakpoint)
 631     return;
 632
 633   if (b->number <= 0)
 634     return;
 635
 636   target_terminal_ours ();
 637
 638   fprintf_unfiltered (mi->event_channel, "breakpoint-deleted,id=\"%d\"",
 639                       b->number);
 640
 641   gdb_flush (mi->event_channel);
 642 }
 643
 644 /* Emit notification about modified breakpoint.  */
 645
 646 static void
 647 mi_breakpoint_modified (struct breakpoint *b)
 648 {
 649   struct mi_interp *mi = top_level_interpreter_data ();
 650   struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
 651   volatile struct gdb_exception e;
 652
 653   if (mi_suppress_notification.breakpoint)
 654     return;
 655
 656   if (b->number <= 0)
 657     return;
 658
 659   target_terminal_ours ();
 660   fprintf_unfiltered (mi->event_channel,
 661                       "breakpoint-modified");
 662   /* We want the output from gdb_breakpoint_query to go to
 663      mi->event_channel.  One approach would be to just call
 664      gdb_breakpoint_query, and then use mi_out_put to send the current
 665      content of mi_outout into mi->event_channel.  However, that will
 666      break if anything is output to mi_uiout prior to calling the
 667      breakpoint_created notifications.  So, we use
 668      ui_out_redirect.  */
 669   ui_out_redirect (mi_uiout, mi->event_channel);
 670   TRY_CATCH (e, RETURN_MASK_ERROR)
 671     gdb_breakpoint_query (mi_uiout, b->number, NULL);
 672   ui_out_redirect (mi_uiout, NULL);
 673
 674   gdb_flush (mi->event_channel);
 675 }
 676
 677 static int
 678 mi_output_running_pid (struct thread_info *info, void *arg)
 679 {
 680   ptid_t *ptid = arg;
 681
 682   if (ptid_get_pid (*ptid) == ptid_get_pid (info->ptid))
 683     fprintf_unfiltered (raw_stdout,
 684                         "*running,thread-id=\"%d\"\n",
 685                         info->num);
 686
 687   return 0;
 688 }
 689
 690 static int
 691 mi_inferior_count (struct inferior *inf, void *arg)
 692 {
 693   if (inf->pid != 0)
 694     {
 695       int *count_p = arg;
 696       (*count_p)++;
 697     }
 698
 699   return 0;
 700 }
 701
 702 static void
 703 mi_on_resume (ptid_t ptid)
 704 {
 705   struct thread_info *tp = NULL;
 706
 707   if (ptid_equal (ptid, minus_one_ptid) || ptid_is_pid (ptid))
 708     tp = inferior_thread ();
 709   else
 710     tp = find_thread_ptid (ptid);
 711
 712   /* Suppress output while calling an inferior function.  */
 713   if (tp->control.in_infcall)
 714     return;
 715
 716   /* To cater for older frontends, emit ^running, but do it only once
 717      per each command.  We do it here, since at this point we know
 718      that the target was successfully resumed, and in non-async mode,
 719      we won't return back to MI interpreter code until the target
 720      is done running, so delaying the output of "^running" until then
 721      will make it impossible for frontend to know what's going on.
 722
 723      In future (MI3), we'll be outputting "^done" here.  */
 724   if (!running_result_record_printed && mi_proceeded)
 725     {
 726       fprintf_unfiltered (raw_stdout, "%s^running\n",
 727                           current_token ? current_token : "");
 728     }
 729
 730   if (ptid_get_pid (ptid) == -1)
 731     fprintf_unfiltered (raw_stdout, "*running,thread-id=\"all\"\n");
 732   else if (ptid_is_pid (ptid))
 733     {
 734       int count = 0;
 735
 736       /* Backwards compatibility.  If there's only one inferior,
 737          output "all", otherwise, output each resumed thread
 738          individually.  */
 739       iterate_over_inferiors (mi_inferior_count, &count);
 740
 741       if (count == 1)
 742         fprintf_unfiltered (raw_stdout, "*running,thread-id=\"all\"\n");
 743       else
 744         iterate_over_threads (mi_output_running_pid, &ptid);
 745     }
 746   else
 747     {
 748       struct thread_info *ti = find_thread_ptid (ptid);
 749
 750       gdb_assert (ti);
 751       fprintf_unfiltered (raw_stdout, "*running,thread-id=\"%d\"\n", ti->num);
 752     }
 753
 754   if (!running_result_record_printed && mi_proceeded)
 755     {
 756       running_result_record_printed = 1;
 757       /* This is what gdb used to do historically -- printing prompt even if
 758          it cannot actually accept any input.  This will be surely removed
 759          for MI3, and may be removed even earler.  */
 760       /* FIXME: review the use of target_is_async_p here -- is that
 761          what we want? */
 762       if (!target_is_async_p ())
 763         fputs_unfiltered ("(gdb) \n", raw_stdout);
 764     }
 765   gdb_flush (raw_stdout);
 766 }
 767
 768 static void
 769 mi_solib_loaded (struct so_list *solib)
 770 {
 771   struct mi_interp *mi = top_level_interpreter_data ();
 772
 773   target_terminal_ours ();
 774   if (gdbarch_has_global_solist (target_gdbarch ()))
 775     fprintf_unfiltered (mi->event_channel,
 776                         "library-loaded,id=\"%s\",target-name=\"%s\","
 777                         "host-name=\"%s\",symbols-loaded=\"%d\"",
 778                         solib->so_original_name, solib->so_original_name,
 779                         solib->so_name, solib->symbols_loaded);
 780   else
 781     fprintf_unfiltered (mi->event_channel,
 782                         "library-loaded,id=\"%s\",target-name=\"%s\","
 783                         "host-name=\"%s\",symbols-loaded=\"%d\","
 784                         "thread-group=\"i%d\"",
 785                         solib->so_original_name, solib->so_original_name,
 786                         solib->so_name, solib->symbols_loaded,
 787                         current_inferior ()->num);
 788
 789   gdb_flush (mi->event_channel);
 790 }
 791
 792 static void
 793 mi_solib_unloaded (struct so_list *solib)
 794 {
 795   struct mi_interp *mi = top_level_interpreter_data ();
 796
 797   target_terminal_ours ();
 798   if (gdbarch_has_global_solist (target_gdbarch ()))
 799     fprintf_unfiltered (mi->event_channel,
 800                         "library-unloaded,id=\"%s\",target-name=\"%s\","
 801                         "host-name=\"%s\"",
 802                         solib->so_original_name, solib->so_original_name,
 803                         solib->so_name);
 804   else
 805     fprintf_unfiltered (mi->event_channel,
 806                         "library-unloaded,id=\"%s\",target-name=\"%s\","
 807                         "host-name=\"%s\",thread-group=\"i%d\"",
 808                         solib->so_original_name, solib->so_original_name,
 809                         solib->so_name, current_inferior ()->num);
 810
 811   gdb_flush (mi->event_channel);
 812 }
 813
 814 /* Emit notification about the command parameter change.  */
 815
 816 static void
 817 mi_command_param_changed (const char *param, const char *value)
 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.cmd_param_changed)
 823     return;
 824
 825   target_terminal_ours ();
 826
 827   fprintf_unfiltered (mi->event_channel,
 828                       "cmd-param-changed");
 829
 830   ui_out_redirect (mi_uiout, mi->event_channel);
 831
 832   ui_out_field_string (mi_uiout, "param", param);
 833   ui_out_field_string (mi_uiout, "value", value);
 834
 835   ui_out_redirect (mi_uiout, NULL);
 836
 837   gdb_flush (mi->event_channel);
 838 }
 839
 840 /* Emit notification about the target memory change.  */
 841
 842 static void
 843 mi_memory_changed (struct inferior *inferior, CORE_ADDR memaddr,
 844                    ssize_t len, const bfd_byte *myaddr)
 845 {
 846   struct mi_interp *mi = top_level_interpreter_data ();
 847   struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
 848   struct obj_section *sec;
 849
 850   if (mi_suppress_notification.memory)
 851     return;
 852
 853   target_terminal_ours ();
 854
 855   fprintf_unfiltered (mi->event_channel,
 856                       "memory-changed");
 857
 858   ui_out_redirect (mi_uiout, mi->event_channel);
 859
 860   ui_out_field_fmt (mi_uiout, "thread-group", "i%d", inferior->num);
 861   ui_out_field_core_addr (mi_uiout, "addr", target_gdbarch (), memaddr);
 862   ui_out_field_fmt (mi_uiout, "len", "0x%zx", len);
 863
 864   /* Append 'type=code' into notification if MEMADDR falls in the range of
 865      sections contain code.  */
 866   sec = find_pc_section (memaddr);
 867   if (sec != NULL && sec->objfile != NULL)
 868     {
 869       flagword flags = bfd_get_section_flags (sec->objfile->obfd,
 870                                               sec->the_bfd_section);
 871
 872       if (flags & SEC_CODE)
 873         ui_out_field_string (mi_uiout, "type", "code");
 874     }
 875
 876   ui_out_redirect (mi_uiout, NULL);
 877
 878   gdb_flush (mi->event_channel);
 879 }
 880
 881 static int
 882 report_initial_inferior (struct inferior *inf, void *closure)
 883 {
 884   /* This function is called from mi_intepreter_init, and since
 885      mi_inferior_added assumes that inferior is fully initialized
 886      and top_level_interpreter_data is set, we cannot call
 887      it here.  */
 888   struct mi_interp *mi = closure;
 889
 890   target_terminal_ours ();
 891   fprintf_unfiltered (mi->event_channel,
 892                       "thread-group-added,id=\"i%d\"",
 893                       inf->num);
 894   gdb_flush (mi->event_channel);
 895   return 0;
 896 }
 897
 898 static struct ui_out *
 899 mi_ui_out (struct interp *interp)
 900 {
 901   struct mi_interp *mi = interp_data (interp);
 902
 903   return mi->uiout;
 904 }
 905
 906 /* Save the original value of raw_stdout here when logging, so we can
 907    restore correctly when done.  */
 908
 909 static struct ui_file *saved_raw_stdout;
 910
 911 /* Do MI-specific logging actions; save raw_stdout, and change all
 912    the consoles to use the supplied ui-file(s).  */
 913
 914 static int
 915 mi_set_logging (struct interp *interp, int start_log,
 916                 struct ui_file *out, struct ui_file *logfile)
 917 {
 918   struct mi_interp *mi = interp_data (interp);
 919
 920   if (!mi)
 921     return 0;
 922
 923   if (start_log)
 924     {
 925       /* The tee created already is based on gdb_stdout, which for MI
 926          is a console and so we end up in an infinite loop of console
 927          writing to ui_file writing to console etc.  So discard the
 928          existing tee (it hasn't been used yet, and MI won't ever use
 929          it), and create one based on raw_stdout instead.  */
 930       if (logfile)
 931         {
 932           ui_file_delete (out);
 933           out = tee_file_new (raw_stdout, 0, logfile, 0);
 934         }
 935
 936       saved_raw_stdout = raw_stdout;
 937       raw_stdout = out;
 938     }
 939   else
 940     {
 941       raw_stdout = saved_raw_stdout;
 942       saved_raw_stdout = NULL;
 943     }
 944
 945   mi_console_set_raw (mi->out, raw_stdout);
 946   mi_console_set_raw (mi->err, raw_stdout);
 947   mi_console_set_raw (mi->log, raw_stdout);
 948   mi_console_set_raw (mi->targ, raw_stdout);
 949   mi_console_set_raw (mi->event_channel, raw_stdout);
 950
 951   return 1;
 952 }
 953
 954 extern initialize_file_ftype _initialize_mi_interp; /* -Wmissing-prototypes */
 955
 956 void
 957 _initialize_mi_interp (void)
 958 {
 959   static const struct interp_procs procs =
 960     {
 961       mi_interpreter_init,      /* init_proc */
 962       mi_interpreter_resume,    /* resume_proc */
 963       mi_interpreter_suspend,   /* suspend_proc */
 964       mi_interpreter_exec,      /* exec_proc */
 965       mi_interpreter_prompt_p,  /* prompt_proc_p */
 966       mi_ui_out,                /* ui_out_proc */
 967       mi_set_logging,           /* set_logging_proc */
 968       mi_command_loop           /* command_loop_proc */
 969     };
 970
 971   /* The various interpreter levels.  */
 972   interp_add (interp_new (INTERP_MI1, &procs));
 973   interp_add (interp_new (INTERP_MI2, &procs));
 974   interp_add (interp_new (INTERP_MI3, &procs));
 975   interp_add (interp_new (INTERP_MI, &procs));
 976 }