gdb/mi/mi-interp.c - gdb

Global variables defined

Functions defined

Source code

  1. /* MI Interpreter Definitions and Commands for GDB, the GNU debugger.

  3.    Copyright (C) 2002-2015 Free Software Foundation, Inc.

  5.    This file is part of GDB.

  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.

  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.

  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/>.  */

  20. #include "defs.h"
  21. #include "interps.h"
  22. #include "event-top.h"
  23. #include "event-loop.h"
  24. #include "inferior.h"
  25. #include "infrun.h"
  26. #include "ui-out.h"
  27. #include "top.h"
  28. #include "mi-main.h"
  29. #include "mi-cmds.h"
  30. #include "mi-out.h"
  31. #include "mi-console.h"
  32. #include "mi-common.h"
  33. #include "observer.h"
  34. #include "gdbthread.h"
  35. #include "solist.h"
  36. #include "gdb.h"
  37. #include "objfiles.h"
  38. #include "tracepoint.h"
  39. #include "cli-out.h"

  41. /* These are the interpreter setup, etc. functions for the MI
  42.    interpreter.  */

  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);

  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.  */

  52. static int mi_interp_query_hook (const char *ctlstr, va_list ap)
  53.   ATTRIBUTE_PRINTF (1, 0);

  55. static void mi_insert_notify_hooks (void);
  56. static void mi_remove_notify_hooks (void);

  58. static void mi_on_signal_received (enum gdb_signal siggnal);
  59. static void mi_on_end_stepping_range (void);
  60. static void mi_on_signal_exited (enum gdb_signal siggnal);
  61. static void mi_on_exited (int exitstatus);
  62. static void mi_on_normal_stop (struct bpstats *bs, int print_frame);
  63. static void mi_on_no_history (void);

  65. static void mi_new_thread (struct thread_info *t);
  66. static void mi_thread_exit (struct thread_info *t, int silent);
  67. static void mi_record_changed (struct inferior*, int);
  68. static void mi_inferior_added (struct inferior *inf);
  69. static void mi_inferior_appeared (struct inferior *inf);
  70. static void mi_inferior_exit (struct inferior *inf);
  71. static void mi_inferior_removed (struct inferior *inf);
  72. static void mi_on_resume (ptid_t ptid);
  73. static void mi_solib_loaded (struct so_list *solib);
  74. static void mi_solib_unloaded (struct so_list *solib);
  75. static void mi_about_to_proceed (void);
  76. static void mi_traceframe_changed (int tfnum, int tpnum);
  77. static void mi_tsv_created (const struct trace_state_variable *tsv);
  78. static void mi_tsv_deleted (const struct trace_state_variable *tsv);
  79. static void mi_tsv_modified (const struct trace_state_variable *tsv);
  80. static void mi_breakpoint_created (struct breakpoint *b);
  81. static void mi_breakpoint_deleted (struct breakpoint *b);
  82. static void mi_breakpoint_modified (struct breakpoint *b);
  83. static void mi_command_param_changed (const char *param, const char *value);
  84. static void mi_memory_changed (struct inferior *inf, CORE_ADDR memaddr,
  85.                                ssize_t len, const bfd_byte *myaddr);
  86. static void mi_on_sync_execution_done (void);

  88. static int report_initial_inferior (struct inferior *inf, void *closure);

  90. static void *
  91. ‌mi_interpreter_init (struct interp *interp, int top_level)
  92. {
  93.   struct mi_interp *mi = XNEW (struct mi_interp);
  94.   const char *name;
  95.   int mi_version;

  97.   /* Assign the output channel created at startup to its own global,
  98.      so that we can create a console channel that encapsulates and
  99.      prefixes all gdb_output-type bits coming from the rest of the
  100.      debugger.  */

  102.   raw_stdout = gdb_stdout;

  104.   /* Create MI console channels, each with a different prefix so they
  105.      can be distinguished.  */
  106.   mi->out = mi_console_file_new (raw_stdout, "~", '"');
  107.   mi->err = mi_console_file_new (raw_stdout, "&", '"');
  108.   mi->log = mi->err;
  109.   mi->targ = mi_console_file_new (raw_stdout, "@", '"');
  110.   mi->event_channel = mi_console_file_new (raw_stdout, "=", 0);

  112.   name = interp_name (interp);
  113.   /* INTERP_MI selects the most recent released version.  "mi2" was
  114.      released as part of GDB 6.0.  */
  115.   if (strcmp (name, INTERP_MI) == 0)
  116.     mi_version = 2;
  117.   else if (strcmp (name, INTERP_MI1) == 0)
  118.     mi_version = 1;
  119.   else if (strcmp (name, INTERP_MI2) == 0)
  120.     mi_version = 2;
  121.   else if (strcmp (name, INTERP_MI3) == 0)
  122.     mi_version = 3;
  123.   else
  124.     gdb_assert_not_reached ("unhandled MI version");

  126.   mi->mi_uiout = mi_out_new (mi_version);
  127.   mi->cli_uiout = cli_out_new (mi->out);

  129.   /* There are installed even if MI is not the top level interpreter.
  130.      The callbacks themselves decide whether to be skipped.  */
  131.   observer_attach_signal_received (mi_on_signal_received);
  132.   observer_attach_end_stepping_range (mi_on_end_stepping_range);
  133.   observer_attach_signal_exited (mi_on_signal_exited);
  134.   observer_attach_exited (mi_on_exited);
  135.   observer_attach_no_history (mi_on_no_history);

  137.   if (top_level)
  138.     {
  139.       observer_attach_new_thread (mi_new_thread);
  140.       observer_attach_thread_exit (mi_thread_exit);
  141.       observer_attach_inferior_added (mi_inferior_added);
  142.       observer_attach_inferior_appeared (mi_inferior_appeared);
  143.       observer_attach_inferior_exit (mi_inferior_exit);
  144.       observer_attach_inferior_removed (mi_inferior_removed);
  145.       observer_attach_record_changed (mi_record_changed);
  146.       observer_attach_normal_stop (mi_on_normal_stop);
  147.       observer_attach_target_resumed (mi_on_resume);
  148.       observer_attach_solib_loaded (mi_solib_loaded);
  149.       observer_attach_solib_unloaded (mi_solib_unloaded);
  150.       observer_attach_about_to_proceed (mi_about_to_proceed);
  151.       observer_attach_traceframe_changed (mi_traceframe_changed);
  152.       observer_attach_tsv_created (mi_tsv_created);
  153.       observer_attach_tsv_deleted (mi_tsv_deleted);
  154.       observer_attach_tsv_modified (mi_tsv_modified);
  155.       observer_attach_breakpoint_created (mi_breakpoint_created);
  156.       observer_attach_breakpoint_deleted (mi_breakpoint_deleted);
  157.       observer_attach_breakpoint_modified (mi_breakpoint_modified);
  158.       observer_attach_command_param_changed (mi_command_param_changed);
  159.       observer_attach_memory_changed (mi_memory_changed);
  160.       observer_attach_sync_execution_done (mi_on_sync_execution_done);

  162.       /* The initial inferior is created before this function is
  163.          called, so we need to report it explicitly.  Use iteration in
  164.          case future version of GDB creates more than one inferior
  165.          up-front.  */
  166.       iterate_over_inferiors (report_initial_inferior, mi);
  167.     }

  169.   return mi;
  170. }

  172. static int
  173. ‌mi_interpreter_resume (void *data)
  174. {
  175.   struct mi_interp *mi = data;

  177.   /* As per hack note in mi_interpreter_init, swap in the output
  178.      channels... */
  179.   gdb_setup_readline ();

  181.   /* These overwrite some of the initialization done in
  182.      _intialize_event_loop.  */
  183.   call_readline = gdb_readline2;
  184.   input_handler = mi_execute_command_input_handler;
  185.   async_command_editing_p = 0;
  186.   /* FIXME: This is a total hack for now.  PB's use of the MI
  187.      implicitly relies on a bug in the async support which allows
  188.      asynchronous commands to leak through the commmand loop.  The bug
  189.      involves (but is not limited to) the fact that sync_execution was
  190.      erroneously initialized to 0.  Duplicate by initializing it thus
  191.      here...  */
  192.   sync_execution = 0;

  194.   gdb_stdout = mi->out;
  195.   /* Route error and log output through the MI.  */
  196.   gdb_stderr = mi->err;
  197.   gdb_stdlog = mi->log;
  198.   /* Route target output through the MI.  */
  199.   gdb_stdtarg = mi->targ;
  200.   /* Route target error through the MI as well.  */
  201.   gdb_stdtargerr = mi->targ;

  203.   /* Replace all the hooks that we know about.  There really needs to
  204.      be a better way of doing this... */
  205.   clear_interpreter_hooks ();

  207.   deprecated_show_load_progress = mi_load_progress;

  209.   return 1;
  210. }

  212. static int
  213. ‌mi_interpreter_suspend (void *data)
  214. {
  215.   gdb_disable_readline ();
  216.   return 1;
  217. }

  219. static struct gdb_exception
  220. ‌mi_interpreter_exec (void *data, const char *command)
  221. {
  222.   mi_execute_command_wrapper (command);
  223.   return exception_none;
  224. }

  226. void
  227. ‌mi_cmd_interpreter_exec (char *command, char **argv, int argc)
  228. {
  229.   struct interp *interp_to_use;
  230.   int i;
  231.   char *mi_error_message = NULL;
  232.   struct cleanup *old_chain;

  234.   if (argc < 2)
  235.     error (_("-interpreter-exec: "
  236.              "Usage: -interpreter-exec interp command"));

  238.   interp_to_use = interp_lookup (argv[0]);
  239.   if (interp_to_use == NULL)
  240.     error (_("-interpreter-exec: could not find interpreter \"%s\""),
  241.            argv[0]);

  243.   /* Note that unlike the CLI version of this command, we don't
  244.      actually set INTERP_TO_USE as the current interpreter, as we
  245.      still want gdb_stdout, etc. to point at MI streams.  */

  247.   /* Insert the MI out hooks, making sure to also call the
  248.      interpreter's hooks if it has any.  */
  249.   /* KRS: We shouldn't need this... Events should be installed and
  250.      they should just ALWAYS fire something out down the MI
  251.      channel.  */
  252.   mi_insert_notify_hooks ();

  254.   /* Now run the code.  */

  256.   old_chain = make_cleanup (null_cleanup, 0);
  257.   for (i = 1; i < argc; i++)
  258.     {
  259.       struct gdb_exception e = interp_exec (interp_to_use, argv[i]);

  261.       if (e.reason < 0)
  262.         {
  263.           mi_error_message = xstrdup (e.message);
  264.           make_cleanup (xfree, mi_error_message);
  265.           break;
  266.         }
  267.     }

  269.   mi_remove_notify_hooks ();

  271.   if (mi_error_message != NULL)
  272.     error ("%s", mi_error_message);
  273.   do_cleanups (old_chain);
  274. }

  276. /* This inserts a number of hooks that are meant to produce
  277.    async-notify ("=") MI messages while running commands in another
  278.    interpreter using mi_interpreter_exec.  The canonical use for this
  279.    is to allow access to the gdb CLI interpreter from within the MI,
  280.    while still producing MI style output when actions in the CLI
  281.    command change GDB's state.  */

  283. static void
  284. ‌mi_insert_notify_hooks (void)
  285. {
  286.   deprecated_query_hook = mi_interp_query_hook;
  287. }

  289. static void
  290. ‌mi_remove_notify_hooks (void)
  291. {
  292.   deprecated_query_hook = NULL;
  293. }

  295. static int
  296. ‌mi_interp_query_hook (const char *ctlstr, va_list ap)
  297. {
  298.   return 1;
  299. }

  301. static void
  302. ‌mi_execute_command_wrapper (const char *cmd)
  303. {
  304.   mi_execute_command (cmd, stdin == instream);
  305. }

  307. /* Observer for the synchronous_command_done notification.  */

  309. static void
  310. ‌mi_on_sync_execution_done (void)
  311. {
  312.   /* MI generally prints a prompt after a command, indicating it's
  313.      ready for further input.  However, due to an historical wart, if
  314.      MI async, and a (CLI) synchronous command was issued, then we
  315.      will print the prompt right after printing "^running", even if we
  316.      cannot actually accept any input until the target stops.  See
  317.      mi_on_resume.  However, if the target is async but MI is sync,
  318.      then we need to output the MI prompt now, to replicate gdb's
  319.      behavior when neither the target nor MI are async.  (Note this
  320.      observer is only called by the asynchronous target event handling
  321.      code.)  */
  322.   if (!mi_async_p ())
  323.     {
  324.       fputs_unfiltered ("(gdb) \n", raw_stdout);
  325.       gdb_flush (raw_stdout);
  326.     }
  327. }

  329. /* mi_execute_command_wrapper wrapper suitable for INPUT_HANDLER.  */

  331. static void
  332. ‌mi_execute_command_input_handler (char *cmd)
  333. {
  334.   mi_execute_command_wrapper (cmd);

  336.   /* MI generally prints a prompt after a command, indicating it's
  337.      ready for further input.  However, due to an historical wart, if
  338.      MI is async, and a synchronous command was issued, then we will
  339.      print the prompt right after printing "^running", even if we
  340.      cannot actually accept any input until the target stops.  See
  341.      mi_on_resume.

  343.      If MI is not async, then we print the prompt when the command
  344.      finishes.  If the target is sync, that means output the prompt
  345.      now, as in that case executing a command doesn't return until the
  346.      command is done.  However, if the target is async, we go back to
  347.      the event loop and output the prompt in the
  348.      'synchronous_command_done' observer.  */
  349.   if (!target_is_async_p () || !sync_execution)
  350.     {
  351.       fputs_unfiltered ("(gdb) \n", raw_stdout);
  352.       gdb_flush (raw_stdout);
  353.     }
  354. }

  356. static void
  357. ‌mi_command_loop (void *data)
  358. {
  359.   /* Turn off 8 bit strings in quoted output.  Any character with the
  360.      high bit set is printed using C's octal format.  */
  361.   sevenbit_strings = 1;

  363.   /* Tell the world that we're alive.  */
  364.   fputs_unfiltered ("(gdb) \n", raw_stdout);
  365.   gdb_flush (raw_stdout);

  367.   start_event_loop ();
  368. }

  370. static void
  371. ‌mi_new_thread (struct thread_info *t)
  372. {
  373.   struct mi_interp *mi = top_level_interpreter_data ();
  374.   struct inferior *inf = find_inferior_ptid (t->ptid);

  376.   gdb_assert (inf);

  378.   fprintf_unfiltered (mi->event_channel,
  379.                       "thread-created,id=\"%d\",group-id=\"i%d\"",
  380.                       t->num, inf->num);
  381.   gdb_flush (mi->event_channel);
  382. }

  384. static void
  385. ‌mi_thread_exit (struct thread_info *t, int silent)
  386. {
  387.   struct mi_interp *mi;
  388.   struct inferior *inf;
  389.   struct cleanup *old_chain;

  391.   if (silent)
  392.     return;

  394.   inf = find_inferior_ptid (t->ptid);

  396.   mi = top_level_interpreter_data ();
  397.   old_chain = make_cleanup_restore_target_terminal ();
  398.   target_terminal_ours ();
  399.   fprintf_unfiltered (mi->event_channel,
  400.                       "thread-exited,id=\"%d\",group-id=\"i%d\"",
  401.                       t->num, inf->num);
  402.   gdb_flush (mi->event_channel);

  404.   do_cleanups (old_chain);
  405. }

  407. /* Emit notification on changing the state of record.  */

  409. static void
  410. ‌mi_record_changed (struct inferior *inferior, int started)
  411. {
  412.   struct mi_interp *mi = top_level_interpreter_data ();

  414.   fprintf_unfiltered (mi->event_channel,  "record-%s,thread-group=\"i%d\"",
  415.                       started ? "started" : "stopped", inferior->num);

  417.   gdb_flush (mi->event_channel);
  418. }

  420. static void
  421. ‌mi_inferior_added (struct inferior *inf)
  422. {
  423.   struct mi_interp *mi = top_level_interpreter_data ();

  425.   target_terminal_ours ();
  426.   fprintf_unfiltered (mi->event_channel,
  427.                       "thread-group-added,id=\"i%d\"",
  428.                       inf->num);
  429.   gdb_flush (mi->event_channel);
  430. }

  432. static void
  433. ‌mi_inferior_appeared (struct inferior *inf)
  434. {
  435.   struct mi_interp *mi = top_level_interpreter_data ();

  437.   target_terminal_ours ();
  438.   fprintf_unfiltered (mi->event_channel,
  439.                       "thread-group-started,id=\"i%d\",pid=\"%d\"",
  440.                       inf->num, inf->pid);
  441.   gdb_flush (mi->event_channel);
  442. }

  444. static void
  445. ‌mi_inferior_exit (struct inferior *inf)
  446. {
  447.   struct mi_interp *mi = top_level_interpreter_data ();

  449.   target_terminal_ours ();
  450.   if (inf->has_exit_code)
  451.     fprintf_unfiltered (mi->event_channel,
  452.                         "thread-group-exited,id=\"i%d\",exit-code=\"%s\"",
  453.                         inf->num, int_string (inf->exit_code, 8, 0, 0, 1));
  454.   else
  455.     fprintf_unfiltered (mi->event_channel,
  456.                         "thread-group-exited,id=\"i%d\"", inf->num);

  458.   gdb_flush (mi->event_channel);
  459. }

  461. static void
  462. ‌mi_inferior_removed (struct inferior *inf)
  463. {
  464.   struct mi_interp *mi = top_level_interpreter_data ();

  466.   target_terminal_ours ();
  467.   fprintf_unfiltered (mi->event_channel,
  468.                       "thread-group-removed,id=\"i%d\"",
  469.                       inf->num);
  470.   gdb_flush (mi->event_channel);
  471. }

  473. /* Cleanup that restores a previous current uiout.  */

  475. static void
  476. ‌restore_current_uiout_cleanup (void *arg)
  477. {
  478.   struct ui_out *saved_uiout = arg;

  480.   current_uiout = saved_uiout;
  481. }

  483. /* Return the MI interpreter, if it is active -- either because it's
  484.    the top-level interpreter or the interpreter executing the current
  485.    command.  Returns NULL if the MI interpreter is not being used.  */

  487. static struct interp *
  488. ‌find_mi_interpreter (void)
  489. {
  490.   struct interp *interp;

  492.   interp = top_level_interpreter ();
  493.   if (ui_out_is_mi_like_p (interp_ui_out (interp)))
  494.     return interp;

  496.   interp = command_interp ();
  497.   if (ui_out_is_mi_like_p (interp_ui_out (interp)))
  498.     return interp;

  500.   return NULL;
  501. }

  503. /* Return the MI_INTERP structure of the active MI interpreter.
  504.    Returns NULL if MI is not active.  */

  506. static struct mi_interp *
  507. ‌mi_interp_data (void)
  508. {
  509.   struct interp *interp = find_mi_interpreter ();

  511.   if (interp != NULL)
  512.     return interp_data (interp);
  513.   return NULL;
  514. }

  516. /* Observers for several run control events that print why the
  517.    inferior has stopped to both the the MI event channel and to the MI
  518.    console.  If the MI interpreter is not active, print nothing.  */

  520. /* Observer for the signal_received notification.  */

  522. static void
  523. ‌mi_on_signal_received (enum gdb_signal siggnal)
  524. {
  525.   struct mi_interp *mi = mi_interp_data ();

  527.   if (mi == NULL)
  528.     return;

  530.   print_signal_received_reason (mi->mi_uiout, siggnal);
  531.   print_signal_received_reason (mi->cli_uiout, siggnal);
  532. }

  534. /* Observer for the end_stepping_range notification.  */

  536. static void
  537. ‌mi_on_end_stepping_range (void)
  538. {
  539.   struct mi_interp *mi = mi_interp_data ();

  541.   if (mi == NULL)
  542.     return;

  544.   print_end_stepping_range_reason (mi->mi_uiout);
  545.   print_end_stepping_range_reason (mi->cli_uiout);
  546. }

  548. /* Observer for the signal_exited notification.  */

  550. static void
  551. ‌mi_on_signal_exited (enum gdb_signal siggnal)
  552. {
  553.   struct mi_interp *mi = mi_interp_data ();

  555.   if (mi == NULL)
  556.     return;

  558.   print_signal_exited_reason (mi->mi_uiout, siggnal);
  559.   print_signal_exited_reason (mi->cli_uiout, siggnal);
  560. }

  562. /* Observer for the exited notification.  */

  564. static void
  565. ‌mi_on_exited (int exitstatus)
  566. {
  567.   struct mi_interp *mi = mi_interp_data ();

  569.   if (mi == NULL)
  570.     return;

  572.   print_exited_reason (mi->mi_uiout, exitstatus);
  573.   print_exited_reason (mi->cli_uiout, exitstatus);
  574. }

  576. /* Observer for the no_history notification.  */

  578. static void
  579. ‌mi_on_no_history (void)
  580. {
  581.   struct mi_interp *mi = mi_interp_data ();

  583.   if (mi == NULL)
  584.     return;

  586.   print_no_history_reason (mi->mi_uiout);
  587.   print_no_history_reason (mi->cli_uiout);
  588. }

  590. static void
  591. ‌mi_on_normal_stop (struct bpstats *bs, int print_frame)
  592. {
  593.   /* Since this can be called when CLI command is executing,
  594.      using cli interpreter, be sure to use MI uiout for output,
  595.      not the current one.  */
  596.   struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());

  598.   if (print_frame)
  599.     {
  600.       int core;

  602.       if (current_uiout != mi_uiout)
  603.         {
  604.           /* The normal_stop function has printed frame information
  605.              into CLI uiout, or some other non-MI uiout.  There's no
  606.              way we can extract proper fields from random uiout
  607.              object, so we print the frame again.  In practice, this
  608.              can only happen when running a CLI command in MI.  */
  609.           struct ui_out *saved_uiout = current_uiout;
  610.           struct target_waitstatus last;
  611.           ptid_t last_ptid;

  613.           current_uiout = mi_uiout;

  615.           get_last_target_status (&last_ptid, &last);
  616.           print_stop_event (&last);

  618.           current_uiout = saved_uiout;
  619.         }
  620.       /* Otherwise, frame information has already been printed by
  621.          normal_stop.  */
  622.       else
  623.         {
  624.           /* Breakpoint hits should always be mirrored to the console.
  625.              Deciding what to mirror to the console wrt to breakpoints
  626.              and random stops gets messy real fast.  E.g., say "s"
  627.              trips on a breakpoint.  We'd clearly want to mirror the
  628.              event to the console in this case.  But what about more
  629.              complicated cases like "s&; thread n; s&", and one of
  630.              those steps spawning a new thread, and that thread
  631.              hitting a breakpoint?  It's impossible in general to
  632.              track whether the thread had any relation to the commands
  633.              that had been executed.  So we just simplify and always
  634.              mirror breakpoints and random events to the console.

  636.              Also, CLI execution commands (-interpreter-exec console
  637.              "next", for example) in async mode have the opposite
  638.              issue as described in the "then" branch above --
  639.              normal_stop has already printed frame information to MI
  640.              uiout, but nothing has printed the same information to
  641.              the CLI channel.  We should print the source line to the
  642.              console when stepping or other similar commands, iff the
  643.              step was started by a console command (but not if it was
  644.              started with -exec-step or similar).  */
  645.           struct thread_info *tp = inferior_thread ();

  647.           if ((!tp->control.stop_step
  648.                   && !tp->control.proceed_to_finish)
  649.               || (tp->control.command_interp != NULL
  650.                   && tp->control.command_interp != top_level_interpreter ()))
  651.             {
  652.               struct mi_interp *mi = top_level_interpreter_data ();
  653.               struct target_waitstatus last;
  654.               ptid_t last_ptid;
  655.               struct cleanup *old_chain;

  657.               /* Set the current uiout to CLI uiout temporarily.  */
  658.               old_chain = make_cleanup (restore_current_uiout_cleanup,
  659.                                         current_uiout);
  660.               current_uiout = mi->cli_uiout;

  662.               get_last_target_status (&last_ptid, &last);
  663.               print_stop_event (&last);

  665.               do_cleanups (old_chain);
  666.             }
  667.         }

  669.       ui_out_field_int (mi_uiout, "thread-id",
  670.                         pid_to_thread_id (inferior_ptid));
  671.       if (non_stop)
  672.         {
  673.           struct cleanup *back_to = make_cleanup_ui_out_list_begin_end
  674.             (mi_uiout, "stopped-threads");

  676.           ui_out_field_int (mi_uiout, NULL,
  677.                             pid_to_thread_id (inferior_ptid));
  678.           do_cleanups (back_to);
  679.         }
  680.       else
  681.         ui_out_field_string (mi_uiout, "stopped-threads", "all");

  683.       core = target_core_of_thread (inferior_ptid);
  684.       if (core != -1)
  685.         ui_out_field_int (mi_uiout, "core", core);
  686.     }

  688.   fputs_unfiltered ("*stopped", raw_stdout);
  689.   mi_out_put (mi_uiout, raw_stdout);
  690.   mi_out_rewind (mi_uiout);
  691.   mi_print_timing_maybe ();
  692.   fputs_unfiltered ("\n", raw_stdout);
  693.   gdb_flush (raw_stdout);
  694. }

  696. static void
  697. ‌mi_about_to_proceed (void)
  698. {
  699.   /* Suppress output while calling an inferior function.  */

  701.   if (!ptid_equal (inferior_ptid, null_ptid))
  702.     {
  703.       struct thread_info *tp = inferior_thread ();

  705.       if (tp->control.in_infcall)
  706.         return;
  707.     }

  709.   mi_proceeded = 1;
  710. }

  712. /* When the element is non-zero, no MI notifications will be emitted in
  713.    response to the corresponding observers.  */

  715. ‌struct mi_suppress_notification mi_suppress_notification =
  716.   {
  717.     0,
  718.     0,
  719.     0,
  720.   };

  722. /* Emit notification on changing a traceframe.  */

  724. static void
  725. ‌mi_traceframe_changed (int tfnum, int tpnum)
  726. {
  727.   struct mi_interp *mi = top_level_interpreter_data ();

  729.   if (mi_suppress_notification.traceframe)
  730.     return;

  732.   target_terminal_ours ();

  734.   if (tfnum >= 0)
  735.     fprintf_unfiltered (mi->event_channel, "traceframe-changed,"
  736.                         "num=\"%d\",tracepoint=\"%d\"\n",
  737.                         tfnum, tpnum);
  738.   else
  739.     fprintf_unfiltered (mi->event_channel, "traceframe-changed,end");

  741.   gdb_flush (mi->event_channel);
  742. }

  744. /* Emit notification on creating a trace state variable.  */

  746. static void
  747. ‌mi_tsv_created (const struct trace_state_variable *tsv)
  748. {
  749.   struct mi_interp *mi = top_level_interpreter_data ();

  751.   target_terminal_ours ();

  753.   fprintf_unfiltered (mi->event_channel, "tsv-created,"
  754.                       "name=\"%s\",initial=\"%s\"\n",
  755.                       tsv->name, plongest (tsv->initial_value));

  757.   gdb_flush (mi->event_channel);
  758. }

  760. /* Emit notification on deleting a trace state variable.  */

  762. static void
  763. ‌mi_tsv_deleted (const struct trace_state_variable *tsv)
  764. {
  765.   struct mi_interp *mi = top_level_interpreter_data ();

  767.   target_terminal_ours ();

  769.   if (tsv != NULL)
  770.     fprintf_unfiltered (mi->event_channel, "tsv-deleted,"
  771.                         "name=\"%s\"\n", tsv->name);
  772.   else
  773.     fprintf_unfiltered (mi->event_channel, "tsv-deleted\n");

  775.   gdb_flush (mi->event_channel);
  776. }

  778. /* Emit notification on modifying a trace state variable.  */

  780. static void
  781. ‌mi_tsv_modified (const struct trace_state_variable *tsv)
  782. {
  783.   struct mi_interp *mi = top_level_interpreter_data ();
  784.   struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());

  786.   target_terminal_ours ();

  788.   fprintf_unfiltered (mi->event_channel,
  789.                       "tsv-modified");

  791.   ui_out_redirect (mi_uiout, mi->event_channel);

  793.   ui_out_field_string (mi_uiout, "name", tsv->name);
  794.   ui_out_field_string (mi_uiout, "initial",
  795.                        plongest (tsv->initial_value));
  796.   if (tsv->value_known)
  797.     ui_out_field_string (mi_uiout, "current", plongest (tsv->value));

  799.   ui_out_redirect (mi_uiout, NULL);

  801.   gdb_flush (mi->event_channel);
  802. }

  804. /* Emit notification about a created breakpoint.  */

  806. static void
  807. ‌mi_breakpoint_created (struct breakpoint *b)
  808. {
  809.   struct mi_interp *mi = top_level_interpreter_data ();
  810.   struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
  811.   volatile struct gdb_exception e;

  813.   if (mi_suppress_notification.breakpoint)
  814.     return;

  816.   if (b->number <= 0)
  817.     return;

  819.   target_terminal_ours ();
  820.   fprintf_unfiltered (mi->event_channel,
  821.                       "breakpoint-created");
  822.   /* We want the output from gdb_breakpoint_query to go to
  823.      mi->event_channel.  One approach would be to just call
  824.      gdb_breakpoint_query, and then use mi_out_put to send the current
  825.      content of mi_outout into mi->event_channel.  However, that will
  826.      break if anything is output to mi_uiout prior to calling the
  827.      breakpoint_created notifications.  So, we use
  828.      ui_out_redirect.  */
  829.   ui_out_redirect (mi_uiout, mi->event_channel);
  830.   TRY_CATCH (e, RETURN_MASK_ERROR)
  831.     gdb_breakpoint_query (mi_uiout, b->number, NULL);
  832.   ui_out_redirect (mi_uiout, NULL);

  834.   gdb_flush (mi->event_channel);
  835. }

  837. /* Emit notification about deleted breakpoint.  */

  839. static void
  840. ‌mi_breakpoint_deleted (struct breakpoint *b)
  841. {
  842.   struct mi_interp *mi = top_level_interpreter_data ();

  844.   if (mi_suppress_notification.breakpoint)
  845.     return;

  847.   if (b->number <= 0)
  848.     return;

  850.   target_terminal_ours ();

  852.   fprintf_unfiltered (mi->event_channel, "breakpoint-deleted,id=\"%d\"",
  853.                       b->number);

  855.   gdb_flush (mi->event_channel);
  856. }

  858. /* Emit notification about modified breakpoint.  */

  860. static void
  861. ‌mi_breakpoint_modified (struct breakpoint *b)
  862. {
  863.   struct mi_interp *mi = top_level_interpreter_data ();
  864.   struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
  865.   volatile struct gdb_exception e;

  867.   if (mi_suppress_notification.breakpoint)
  868.     return;

  870.   if (b->number <= 0)
  871.     return;

  873.   target_terminal_ours ();
  874.   fprintf_unfiltered (mi->event_channel,
  875.                       "breakpoint-modified");
  876.   /* We want the output from gdb_breakpoint_query to go to
  877.      mi->event_channel.  One approach would be to just call
  878.      gdb_breakpoint_query, and then use mi_out_put to send the current
  879.      content of mi_outout into mi->event_channel.  However, that will
  880.      break if anything is output to mi_uiout prior to calling the
  881.      breakpoint_created notifications.  So, we use
  882.      ui_out_redirect.  */
  883.   ui_out_redirect (mi_uiout, mi->event_channel);
  884.   TRY_CATCH (e, RETURN_MASK_ERROR)
  885.     gdb_breakpoint_query (mi_uiout, b->number, NULL);
  886.   ui_out_redirect (mi_uiout, NULL);

  888.   gdb_flush (mi->event_channel);
  889. }

  891. static int
  892. ‌mi_output_running_pid (struct thread_info *info, void *arg)
  893. {
  894.   ptid_t *ptid = arg;

  896.   if (ptid_get_pid (*ptid) == ptid_get_pid (info->ptid))
  897.     fprintf_unfiltered (raw_stdout,
  898.                         "*running,thread-id=\"%d\"\n",
  899.                         info->num);

  901.   return 0;
  902. }

  904. static int
  905. ‌mi_inferior_count (struct inferior *inf, void *arg)
  906. {
  907.   if (inf->pid != 0)
  908.     {
  909.       int *count_p = arg;
  910.       (*count_p)++;
  911.     }

  913.   return 0;
  914. }

  916. static void
  917. ‌mi_on_resume (ptid_t ptid)
  918. {
  919.   struct thread_info *tp = NULL;

  921.   if (ptid_equal (ptid, minus_one_ptid) || ptid_is_pid (ptid))
  922.     tp = inferior_thread ();
  923.   else
  924.     tp = find_thread_ptid (ptid);

  926.   /* Suppress output while calling an inferior function.  */
  927.   if (tp->control.in_infcall)
  928.     return;

  930.   /* To cater for older frontends, emit ^running, but do it only once
  931.      per each command.  We do it here, since at this point we know
  932.      that the target was successfully resumed, and in non-async mode,
  933.      we won't return back to MI interpreter code until the target
  934.      is done running, so delaying the output of "^running" until then
  935.      will make it impossible for frontend to know what's going on.

  937.      In future (MI3), we'll be outputting "^done" here.  */
  938.   if (!running_result_record_printed && mi_proceeded)
  939.     {
  940.       fprintf_unfiltered (raw_stdout, "%s^running\n",
  941.                           current_token ? current_token : "");
  942.     }

  944.   if (ptid_get_pid (ptid) == -1)
  945.     fprintf_unfiltered (raw_stdout, "*running,thread-id=\"all\"\n");
  946.   else if (ptid_is_pid (ptid))
  947.     {
  948.       int count = 0;

  950.       /* Backwards compatibility.  If there's only one inferior,
  951.          output "all", otherwise, output each resumed thread
  952.          individually.  */
  953.       iterate_over_inferiors (mi_inferior_count, &count);

  955.       if (count == 1)
  956.         fprintf_unfiltered (raw_stdout, "*running,thread-id=\"all\"\n");
  957.       else
  958.         iterate_over_threads (mi_output_running_pid, &ptid);
  959.     }
  960.   else
  961.     {
  962.       struct thread_info *ti = find_thread_ptid (ptid);

  964.       gdb_assert (ti);
  965.       fprintf_unfiltered (raw_stdout, "*running,thread-id=\"%d\"\n", ti->num);
  966.     }

  968.   if (!running_result_record_printed && mi_proceeded)
  969.     {
  970.       running_result_record_printed = 1;
  971.       /* This is what gdb used to do historically -- printing prompt even if
  972.          it cannot actually accept any input.  This will be surely removed
  973.          for MI3, and may be removed even earlier.  SYNC_EXECUTION is
  974.          checked here because we only need to emit a prompt if a
  975.          synchronous command was issued when the target is async.  */
  976.       if (!target_is_async_p () || sync_execution)
  977.         fputs_unfiltered ("(gdb) \n", raw_stdout);
  978.     }
  979.   gdb_flush (raw_stdout);
  980. }

  982. static void
  983. ‌mi_solib_loaded (struct so_list *solib)
  984. {
  985.   struct mi_interp *mi = top_level_interpreter_data ();
  986.   struct ui_out *uiout = interp_ui_out (top_level_interpreter ());

  988.   target_terminal_ours ();

  990.   fprintf_unfiltered (mi->event_channel, "library-loaded");

  992.   ui_out_redirect (uiout, mi->event_channel);

  994.   ui_out_field_string (uiout, "id", solib->so_original_name);
  995.   ui_out_field_string (uiout, "target-name", solib->so_original_name);
  996.   ui_out_field_string (uiout, "host-name", solib->so_name);
  997.   ui_out_field_int (uiout, "symbols-loaded", solib->symbols_loaded);
  998.   if (!gdbarch_has_global_solist (target_gdbarch ()))
  999.     {
  1000.       ui_out_field_fmt (uiout, "thread-group", "i%d", current_inferior ()->num);
  1001.     }

  1003.   ui_out_redirect (uiout, NULL);

  1005.   gdb_flush (mi->event_channel);
  1006. }

  1008. static void
  1009. ‌mi_solib_unloaded (struct so_list *solib)
  1010. {
  1011.   struct mi_interp *mi = top_level_interpreter_data ();
  1012.   struct ui_out *uiout = interp_ui_out (top_level_interpreter ());

  1014.   target_terminal_ours ();

  1016.   fprintf_unfiltered (mi->event_channel, "library-unloaded");

  1018.   ui_out_redirect (uiout, mi->event_channel);

  1020.   ui_out_field_string (uiout, "id", solib->so_original_name);
  1021.   ui_out_field_string (uiout, "target-name", solib->so_original_name);
  1022.   ui_out_field_string (uiout, "host-name", solib->so_name);
  1023.   if (!gdbarch_has_global_solist (target_gdbarch ()))
  1024.     {
  1025.       ui_out_field_fmt (uiout, "thread-group", "i%d", current_inferior ()->num);
  1026.     }

  1028.   ui_out_redirect (uiout, NULL);

  1030.   gdb_flush (mi->event_channel);
  1031. }

  1033. /* Emit notification about the command parameter change.  */

  1035. static void
  1036. ‌mi_command_param_changed (const char *param, const char *value)
  1037. {
  1038.   struct mi_interp *mi = top_level_interpreter_data ();
  1039.   struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());

  1041.   if (mi_suppress_notification.cmd_param_changed)
  1042.     return;

  1044.   target_terminal_ours ();

  1046.   fprintf_unfiltered (mi->event_channel,
  1047.                       "cmd-param-changed");

  1049.   ui_out_redirect (mi_uiout, mi->event_channel);

  1051.   ui_out_field_string (mi_uiout, "param", param);
  1052.   ui_out_field_string (mi_uiout, "value", value);

  1054.   ui_out_redirect (mi_uiout, NULL);

  1056.   gdb_flush (mi->event_channel);
  1057. }

  1059. /* Emit notification about the target memory change.  */

  1061. static void
  1062. ‌mi_memory_changed (struct inferior *inferior, CORE_ADDR memaddr,
  1063.                    ssize_t len, const bfd_byte *myaddr)
  1064. {
  1065.   struct mi_interp *mi = top_level_interpreter_data ();
  1066.   struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
  1067.   struct obj_section *sec;

  1069.   if (mi_suppress_notification.memory)
  1070.     return;

  1072.   target_terminal_ours ();

  1074.   fprintf_unfiltered (mi->event_channel,
  1075.                       "memory-changed");

  1077.   ui_out_redirect (mi_uiout, mi->event_channel);

  1079.   ui_out_field_fmt (mi_uiout, "thread-group", "i%d", inferior->num);
  1080.   ui_out_field_core_addr (mi_uiout, "addr", target_gdbarch (), memaddr);
  1081.   ui_out_field_fmt (mi_uiout, "len", "%s", hex_string (len));

  1083.   /* Append 'type=code' into notification if MEMADDR falls in the range of
  1084.      sections contain code.  */
  1085.   sec = find_pc_section (memaddr);
  1086.   if (sec != NULL && sec->objfile != NULL)
  1087.     {
  1088.       flagword flags = bfd_get_section_flags (sec->objfile->obfd,
  1089.                                               sec->the_bfd_section);

  1091.       if (flags & SEC_CODE)
  1092.         ui_out_field_string (mi_uiout, "type", "code");
  1093.     }

  1095.   ui_out_redirect (mi_uiout, NULL);

  1097.   gdb_flush (mi->event_channel);
  1098. }

  1100. static int
  1101. ‌report_initial_inferior (struct inferior *inf, void *closure)
  1102. {
  1103.   /* This function is called from mi_intepreter_init, and since
  1104.      mi_inferior_added assumes that inferior is fully initialized
  1105.      and top_level_interpreter_data is set, we cannot call
  1106.      it here.  */
  1107.   struct mi_interp *mi = closure;

  1109.   target_terminal_ours ();
  1110.   fprintf_unfiltered (mi->event_channel,
  1111.                       "thread-group-added,id=\"i%d\"",
  1112.                       inf->num);
  1113.   gdb_flush (mi->event_channel);
  1114.   return 0;
  1115. }

  1117. static struct ui_out *
  1118. ‌mi_ui_out (struct interp *interp)
  1119. {
  1120.   struct mi_interp *mi = interp_data (interp);

  1122.   return mi->mi_uiout;
  1123. }

  1125. /* Save the original value of raw_stdout here when logging, so we can
  1126.    restore correctly when done.  */

  1128. ‌static struct ui_file *saved_raw_stdout;

  1130. /* Do MI-specific logging actions; save raw_stdout, and change all
  1131.    the consoles to use the supplied ui-file(s).  */

  1133. static int
  1134. ‌mi_set_logging (struct interp *interp, int start_log,
  1135.                 struct ui_file *out, struct ui_file *logfile)
  1136. {
  1137.   struct mi_interp *mi = interp_data (interp);

  1139.   if (!mi)
  1140.     return 0;

  1142.   if (start_log)
  1143.     {
  1144.       /* The tee created already is based on gdb_stdout, which for MI
  1145.          is a console and so we end up in an infinite loop of console
  1146.          writing to ui_file writing to console etc.  So discard the
  1147.          existing tee (it hasn't been used yet, and MI won't ever use
  1148.          it), and create one based on raw_stdout instead.  */
  1149.       if (logfile)
  1150.         {
  1151.           ui_file_delete (out);
  1152.           out = tee_file_new (raw_stdout, 0, logfile, 0);
  1153.         }

  1155.       saved_raw_stdout = raw_stdout;
  1156.       raw_stdout = out;
  1157.     }
  1158.   else
  1159.     {
  1160.       raw_stdout = saved_raw_stdout;
  1161.       saved_raw_stdout = NULL;
  1162.     }

  1164.   mi_console_set_raw (mi->out, raw_stdout);
  1165.   mi_console_set_raw (mi->err, raw_stdout);
  1166.   mi_console_set_raw (mi->log, raw_stdout);
  1167.   mi_console_set_raw (mi->targ, raw_stdout);
  1168.   mi_console_set_raw (mi->event_channel, raw_stdout);

  1170.   return 1;
  1171. }

  1173. extern initialize_file_ftype _initialize_mi_interp; /* -Wmissing-prototypes */

  1175. void
  1176. ‌_initialize_mi_interp (void)
  1177. {
  1178.   static const struct interp_procs procs =
  1179.     {
  1180.       mi_interpreter_init,        /* init_proc */
  1181.       mi_interpreter_resume,        /* resume_proc */
  1182.       mi_interpreter_suspend,        /* suspend_proc */
  1183.       mi_interpreter_exec,        /* exec_proc */
  1184.       mi_ui_out,                 /* ui_out_proc */
  1185.       mi_set_logging,                /* set_logging_proc */
  1186.       mi_command_loop                /* command_loop_proc */
  1187.     };

  1189.   /* The various interpreter levels.  */
  1190.   interp_add (interp_new (INTERP_MI1, &procs));
  1191.   interp_add (interp_new (INTERP_MI2, &procs));
  1192.   interp_add (interp_new (INTERP_MI3, &procs));
  1193.   interp_add (interp_new (INTERP_MI, &procs));
  1194. }