1 /* MI Interpreter Definitions and Commands for GDB, the GNU debugger.
3 Copyright (C) 2002-2018 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/>. */
22 #include "event-top.h"
23 #include "event-loop.h"
31 #include "mi-console.h"
32 #include "mi-common.h"
33 #include "observable.h"
34 #include "gdbthread.h"
37 #include "tracepoint.h"
39 #include "thread-fsm.h"
40 #include "cli/cli-interp.h"
42 /* These are the interpreter setup, etc. functions for the MI
45 static void mi_execute_command_wrapper (const char *cmd
);
46 static void mi_execute_command_input_handler (char *cmd
);
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, const char *,
69 static void mi_inferior_added (struct inferior
*inf
);
70 static void mi_inferior_appeared (struct inferior
*inf
);
71 static void mi_inferior_exit (struct inferior
*inf
);
72 static void mi_inferior_removed (struct inferior
*inf
);
73 static void mi_on_resume (ptid_t ptid
);
74 static void mi_solib_loaded (struct so_list
*solib
);
75 static void mi_solib_unloaded (struct so_list
*solib
);
76 static void mi_about_to_proceed (void);
77 static void mi_traceframe_changed (int tfnum
, int tpnum
);
78 static void mi_tsv_created (const struct trace_state_variable
*tsv
);
79 static void mi_tsv_deleted (const struct trace_state_variable
*tsv
);
80 static void mi_tsv_modified (const struct trace_state_variable
*tsv
);
81 static void mi_breakpoint_created (struct breakpoint
*b
);
82 static void mi_breakpoint_deleted (struct breakpoint
*b
);
83 static void mi_breakpoint_modified (struct breakpoint
*b
);
84 static void mi_command_param_changed (const char *param
, const char *value
);
85 static void mi_memory_changed (struct inferior
*inf
, CORE_ADDR memaddr
,
86 ssize_t len
, const bfd_byte
*myaddr
);
87 static void mi_on_sync_execution_done (void);
89 static int report_initial_inferior (struct inferior
*inf
, void *closure
);
91 /* Display the MI prompt. */
94 display_mi_prompt (struct mi_interp
*mi
)
96 struct ui
*ui
= current_ui
;
98 fputs_unfiltered ("(gdb) \n", mi
->raw_stdout
);
99 gdb_flush (mi
->raw_stdout
);
100 ui
->prompt_state
= PROMPTED
;
103 /* Returns the INTERP's data cast as mi_interp if INTERP is an MI, and
104 returns NULL otherwise. */
106 static struct mi_interp
*
107 as_mi_interp (struct interp
*interp
)
109 return dynamic_cast<mi_interp
*> (interp
);
113 mi_interp::init (bool top_level
)
115 mi_interp
*mi
= this;
119 /* Store the current output channel, so that we can create a console
120 channel that encapsulates and prefixes all gdb_output-type bits
121 coming from the rest of the debugger. */
122 mi
->raw_stdout
= gdb_stdout
;
124 /* Create MI console channels, each with a different prefix so they
125 can be distinguished. */
126 mi
->out
= new mi_console_file (mi
->raw_stdout
, "~", '"');
127 mi
->err
= new mi_console_file (mi
->raw_stdout
, "&", '"');
129 mi
->targ
= new mi_console_file (mi
->raw_stdout
, "@", '"');
130 mi
->event_channel
= new mi_console_file (mi
->raw_stdout
, "=", 0);
132 name
= interp_name (this);
133 /* INTERP_MI selects the most recent released version. "mi2" was
134 released as part of GDB 6.0. */
135 if (strcmp (name
, INTERP_MI
) == 0)
137 else if (strcmp (name
, INTERP_MI1
) == 0)
139 else if (strcmp (name
, INTERP_MI2
) == 0)
141 else if (strcmp (name
, INTERP_MI3
) == 0)
144 gdb_assert_not_reached ("unhandled MI version");
146 mi
->mi_uiout
= mi_out_new (mi_version
);
147 mi
->cli_uiout
= cli_out_new (mi
->out
);
151 /* The initial inferior is created before this function is
152 called, so we need to report it explicitly. Use iteration in
153 case future version of GDB creates more than one inferior
155 iterate_over_inferiors (report_initial_inferior
, mi
);
162 struct mi_interp
*mi
= this;
163 struct ui
*ui
= current_ui
;
165 /* As per hack note in mi_interpreter_init, swap in the output
167 gdb_setup_readline (0);
169 ui
->call_readline
= gdb_readline_no_editing_callback
;
170 ui
->input_handler
= mi_execute_command_input_handler
;
172 gdb_stdout
= mi
->out
;
173 /* Route error and log output through the MI. */
174 gdb_stderr
= mi
->err
;
175 gdb_stdlog
= mi
->log
;
176 /* Route target output through the MI. */
177 gdb_stdtarg
= mi
->targ
;
178 /* Route target error through the MI as well. */
179 gdb_stdtargerr
= mi
->targ
;
181 /* Replace all the hooks that we know about. There really needs to
182 be a better way of doing this... */
183 clear_interpreter_hooks ();
185 deprecated_show_load_progress
= mi_load_progress
;
189 mi_interp::suspend ()
191 gdb_disable_readline ();
195 mi_interp::exec (const char *command
)
197 mi_execute_command_wrapper (command
);
198 return exception_none
;
202 mi_cmd_interpreter_exec (const char *command
, char **argv
, int argc
)
204 struct interp
*interp_to_use
;
208 error (_("-interpreter-exec: "
209 "Usage: -interpreter-exec interp command"));
211 interp_to_use
= interp_lookup (current_ui
, argv
[0]);
212 if (interp_to_use
== NULL
)
213 error (_("-interpreter-exec: could not find interpreter \"%s\""),
216 /* Note that unlike the CLI version of this command, we don't
217 actually set INTERP_TO_USE as the current interpreter, as we
218 still want gdb_stdout, etc. to point at MI streams. */
220 /* Insert the MI out hooks, making sure to also call the
221 interpreter's hooks if it has any. */
222 /* KRS: We shouldn't need this... Events should be installed and
223 they should just ALWAYS fire something out down the MI
225 mi_insert_notify_hooks ();
227 /* Now run the code. */
229 std::string mi_error_message
;
230 for (i
= 1; i
< argc
; i
++)
232 struct gdb_exception e
= interp_exec (interp_to_use
, argv
[i
]);
236 mi_error_message
= e
.message
;
241 mi_remove_notify_hooks ();
243 if (!mi_error_message
.empty ())
244 error ("%s", mi_error_message
.c_str ());
247 /* This inserts a number of hooks that are meant to produce
248 async-notify ("=") MI messages while running commands in another
249 interpreter using mi_interpreter_exec. The canonical use for this
250 is to allow access to the gdb CLI interpreter from within the MI,
251 while still producing MI style output when actions in the CLI
252 command change GDB's state. */
255 mi_insert_notify_hooks (void)
257 deprecated_query_hook
= mi_interp_query_hook
;
261 mi_remove_notify_hooks (void)
263 deprecated_query_hook
= NULL
;
267 mi_interp_query_hook (const char *ctlstr
, va_list ap
)
273 mi_execute_command_wrapper (const char *cmd
)
275 struct ui
*ui
= current_ui
;
277 mi_execute_command (cmd
, ui
->instream
== ui
->stdin_stream
);
280 /* Observer for the synchronous_command_done notification. */
283 mi_on_sync_execution_done (void)
285 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
290 /* If MI is sync, then output the MI prompt now, indicating we're
291 ready for further input. */
293 display_mi_prompt (mi
);
296 /* mi_execute_command_wrapper wrapper suitable for INPUT_HANDLER. */
299 mi_execute_command_input_handler (char *cmd
)
301 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
302 struct ui
*ui
= current_ui
;
304 ui
->prompt_state
= PROMPT_NEEDED
;
306 mi_execute_command_wrapper (cmd
);
308 /* Print a prompt, indicating we're ready for further input, unless
309 we just started a synchronous command. In that case, we're about
310 to go back to the event loop and will output the prompt in the
311 'synchronous_command_done' observer when the target next
313 if (ui
->prompt_state
== PROMPT_NEEDED
)
314 display_mi_prompt (mi
);
318 mi_interp::pre_command_loop ()
320 struct mi_interp
*mi
= this;
322 /* Turn off 8 bit strings in quoted output. Any character with the
323 high bit set is printed using C's octal format. */
324 sevenbit_strings
= 1;
326 /* Tell the world that we're alive. */
327 display_mi_prompt (mi
);
331 mi_new_thread (struct thread_info
*t
)
333 struct inferior
*inf
= find_inferior_ptid (t
->ptid
);
337 SWITCH_THRU_ALL_UIS ()
339 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
344 target_terminal::scoped_restore_terminal_state term_state
;
345 target_terminal::ours_for_output ();
347 fprintf_unfiltered (mi
->event_channel
,
348 "thread-created,id=\"%d\",group-id=\"i%d\"",
349 t
->global_num
, inf
->num
);
350 gdb_flush (mi
->event_channel
);
355 mi_thread_exit (struct thread_info
*t
, int silent
)
360 SWITCH_THRU_ALL_UIS ()
362 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
367 target_terminal::scoped_restore_terminal_state term_state
;
368 target_terminal::ours_for_output ();
369 fprintf_unfiltered (mi
->event_channel
,
370 "thread-exited,id=\"%d\",group-id=\"i%d\"",
371 t
->global_num
, t
->inf
->num
);
372 gdb_flush (mi
->event_channel
);
376 /* Emit notification on changing the state of record. */
379 mi_record_changed (struct inferior
*inferior
, int started
, const char *method
,
382 SWITCH_THRU_ALL_UIS ()
384 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
389 target_terminal::scoped_restore_terminal_state term_state
;
390 target_terminal::ours_for_output ();
396 fprintf_unfiltered (mi
->event_channel
,
397 "record-started,thread-group=\"i%d\","
398 "method=\"%s\",format=\"%s\"",
399 inferior
->num
, method
, format
);
403 fprintf_unfiltered (mi
->event_channel
,
404 "record-started,thread-group=\"i%d\","
406 inferior
->num
, method
);
411 fprintf_unfiltered (mi
->event_channel
,
412 "record-stopped,thread-group=\"i%d\"",
416 gdb_flush (mi
->event_channel
);
421 mi_inferior_added (struct inferior
*inf
)
423 SWITCH_THRU_ALL_UIS ()
425 struct interp
*interp
;
426 struct mi_interp
*mi
;
428 /* We'll be called once for the initial inferior, before the top
429 level interpreter is set. */
430 interp
= top_level_interpreter ();
434 mi
= as_mi_interp (interp
);
438 target_terminal::scoped_restore_terminal_state term_state
;
439 target_terminal::ours_for_output ();
441 fprintf_unfiltered (mi
->event_channel
,
442 "thread-group-added,id=\"i%d\"",
444 gdb_flush (mi
->event_channel
);
449 mi_inferior_appeared (struct inferior
*inf
)
451 SWITCH_THRU_ALL_UIS ()
453 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
458 target_terminal::scoped_restore_terminal_state term_state
;
459 target_terminal::ours_for_output ();
461 fprintf_unfiltered (mi
->event_channel
,
462 "thread-group-started,id=\"i%d\",pid=\"%d\"",
464 gdb_flush (mi
->event_channel
);
469 mi_inferior_exit (struct inferior
*inf
)
471 SWITCH_THRU_ALL_UIS ()
473 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
478 target_terminal::scoped_restore_terminal_state term_state
;
479 target_terminal::ours_for_output ();
481 if (inf
->has_exit_code
)
482 fprintf_unfiltered (mi
->event_channel
,
483 "thread-group-exited,id=\"i%d\",exit-code=\"%s\"",
484 inf
->num
, int_string (inf
->exit_code
, 8, 0, 0, 1));
486 fprintf_unfiltered (mi
->event_channel
,
487 "thread-group-exited,id=\"i%d\"", inf
->num
);
489 gdb_flush (mi
->event_channel
);
494 mi_inferior_removed (struct inferior
*inf
)
496 SWITCH_THRU_ALL_UIS ()
498 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
503 target_terminal::scoped_restore_terminal_state term_state
;
504 target_terminal::ours_for_output ();
506 fprintf_unfiltered (mi
->event_channel
,
507 "thread-group-removed,id=\"i%d\"",
509 gdb_flush (mi
->event_channel
);
513 /* Return the MI interpreter, if it is active -- either because it's
514 the top-level interpreter or the interpreter executing the current
515 command. Returns NULL if the MI interpreter is not being used. */
517 static struct mi_interp
*
518 find_mi_interp (void)
520 struct mi_interp
*mi
;
522 mi
= as_mi_interp (top_level_interpreter ());
526 mi
= as_mi_interp (command_interp ());
533 /* Observers for several run control events that print why the
534 inferior has stopped to both the the MI event channel and to the MI
535 console. If the MI interpreter is not active, print nothing. */
537 /* Observer for the signal_received notification. */
540 mi_on_signal_received (enum gdb_signal siggnal
)
542 SWITCH_THRU_ALL_UIS ()
544 struct mi_interp
*mi
= find_mi_interp ();
549 print_signal_received_reason (mi
->mi_uiout
, siggnal
);
550 print_signal_received_reason (mi
->cli_uiout
, siggnal
);
554 /* Observer for the end_stepping_range notification. */
557 mi_on_end_stepping_range (void)
559 SWITCH_THRU_ALL_UIS ()
561 struct mi_interp
*mi
= find_mi_interp ();
566 print_end_stepping_range_reason (mi
->mi_uiout
);
567 print_end_stepping_range_reason (mi
->cli_uiout
);
571 /* Observer for the signal_exited notification. */
574 mi_on_signal_exited (enum gdb_signal siggnal
)
576 SWITCH_THRU_ALL_UIS ()
578 struct mi_interp
*mi
= find_mi_interp ();
583 print_signal_exited_reason (mi
->mi_uiout
, siggnal
);
584 print_signal_exited_reason (mi
->cli_uiout
, siggnal
);
588 /* Observer for the exited notification. */
591 mi_on_exited (int exitstatus
)
593 SWITCH_THRU_ALL_UIS ()
595 struct mi_interp
*mi
= find_mi_interp ();
600 print_exited_reason (mi
->mi_uiout
, exitstatus
);
601 print_exited_reason (mi
->cli_uiout
, exitstatus
);
605 /* Observer for the no_history notification. */
608 mi_on_no_history (void)
610 SWITCH_THRU_ALL_UIS ()
612 struct mi_interp
*mi
= find_mi_interp ();
617 print_no_history_reason (mi
->mi_uiout
);
618 print_no_history_reason (mi
->cli_uiout
);
623 mi_on_normal_stop_1 (struct bpstats
*bs
, int print_frame
)
625 /* Since this can be called when CLI command is executing,
626 using cli interpreter, be sure to use MI uiout for output,
627 not the current one. */
628 struct ui_out
*mi_uiout
= interp_ui_out (top_level_interpreter ());
629 struct mi_interp
*mi
= (struct mi_interp
*) top_level_interpreter ();
633 struct thread_info
*tp
;
635 struct interp
*console_interp
;
637 tp
= inferior_thread ();
639 if (tp
->thread_fsm
!= NULL
640 && thread_fsm_finished_p (tp
->thread_fsm
))
642 enum async_reply_reason reason
;
644 reason
= thread_fsm_async_reply_reason (tp
->thread_fsm
);
645 mi_uiout
->field_string ("reason", async_reason_lookup (reason
));
647 print_stop_event (mi_uiout
);
649 console_interp
= interp_lookup (current_ui
, INTERP_CONSOLE
);
650 if (should_print_stop_to_console (console_interp
, tp
))
651 print_stop_event (mi
->cli_uiout
);
653 mi_uiout
->field_int ("thread-id", tp
->global_num
);
656 ui_out_emit_list
list_emitter (mi_uiout
, "stopped-threads");
658 mi_uiout
->field_int (NULL
, tp
->global_num
);
661 mi_uiout
->field_string ("stopped-threads", "all");
663 core
= target_core_of_thread (inferior_ptid
);
665 mi_uiout
->field_int ("core", core
);
668 fputs_unfiltered ("*stopped", mi
->raw_stdout
);
669 mi_out_put (mi_uiout
, mi
->raw_stdout
);
670 mi_out_rewind (mi_uiout
);
671 mi_print_timing_maybe (mi
->raw_stdout
);
672 fputs_unfiltered ("\n", mi
->raw_stdout
);
673 gdb_flush (mi
->raw_stdout
);
677 mi_on_normal_stop (struct bpstats
*bs
, int print_frame
)
679 SWITCH_THRU_ALL_UIS ()
681 if (as_mi_interp (top_level_interpreter ()) == NULL
)
684 mi_on_normal_stop_1 (bs
, print_frame
);
689 mi_about_to_proceed (void)
691 /* Suppress output while calling an inferior function. */
693 if (!ptid_equal (inferior_ptid
, null_ptid
))
695 struct thread_info
*tp
= inferior_thread ();
697 if (tp
->control
.in_infcall
)
704 /* When the element is non-zero, no MI notifications will be emitted in
705 response to the corresponding observers. */
707 struct mi_suppress_notification mi_suppress_notification
=
715 /* Emit notification on changing a traceframe. */
718 mi_traceframe_changed (int tfnum
, int tpnum
)
720 if (mi_suppress_notification
.traceframe
)
723 SWITCH_THRU_ALL_UIS ()
725 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
730 target_terminal::scoped_restore_terminal_state term_state
;
731 target_terminal::ours_for_output ();
734 fprintf_unfiltered (mi
->event_channel
, "traceframe-changed,"
735 "num=\"%d\",tracepoint=\"%d\"\n",
738 fprintf_unfiltered (mi
->event_channel
, "traceframe-changed,end");
740 gdb_flush (mi
->event_channel
);
744 /* Emit notification on creating a trace state variable. */
747 mi_tsv_created (const struct trace_state_variable
*tsv
)
749 SWITCH_THRU_ALL_UIS ()
751 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
756 target_terminal::scoped_restore_terminal_state term_state
;
757 target_terminal::ours_for_output ();
759 fprintf_unfiltered (mi
->event_channel
, "tsv-created,"
760 "name=\"%s\",initial=\"%s\"\n",
761 tsv
->name
.c_str (), plongest (tsv
->initial_value
));
763 gdb_flush (mi
->event_channel
);
767 /* Emit notification on deleting a trace state variable. */
770 mi_tsv_deleted (const struct trace_state_variable
*tsv
)
772 SWITCH_THRU_ALL_UIS ()
774 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
779 target_terminal::scoped_restore_terminal_state term_state
;
780 target_terminal::ours_for_output ();
783 fprintf_unfiltered (mi
->event_channel
, "tsv-deleted,"
784 "name=\"%s\"\n", tsv
->name
.c_str ());
786 fprintf_unfiltered (mi
->event_channel
, "tsv-deleted\n");
788 gdb_flush (mi
->event_channel
);
792 /* Emit notification on modifying a trace state variable. */
795 mi_tsv_modified (const struct trace_state_variable
*tsv
)
797 SWITCH_THRU_ALL_UIS ()
799 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
800 struct ui_out
*mi_uiout
;
805 mi_uiout
= interp_ui_out (top_level_interpreter ());
807 target_terminal::scoped_restore_terminal_state term_state
;
808 target_terminal::ours_for_output ();
810 fprintf_unfiltered (mi
->event_channel
,
813 mi_uiout
->redirect (mi
->event_channel
);
815 mi_uiout
->field_string ("name", tsv
->name
);
816 mi_uiout
->field_string ("initial",
817 plongest (tsv
->initial_value
));
818 if (tsv
->value_known
)
819 mi_uiout
->field_string ("current", plongest (tsv
->value
));
821 mi_uiout
->redirect (NULL
);
823 gdb_flush (mi
->event_channel
);
827 /* Print breakpoint BP on MI's event channel. */
830 mi_print_breakpoint_for_event (struct mi_interp
*mi
, breakpoint
*bp
)
832 ui_out
*mi_uiout
= interp_ui_out (mi
);
834 /* We want the output from print_breakpoint to go to
835 mi->event_channel. One approach would be to just call
836 print_breakpoint, and then use mi_out_put to send the current
837 content of mi_uiout into mi->event_channel. However, that will
838 break if anything is output to mi_uiout prior to calling the
839 breakpoint_created notifications. So, we use
841 mi_uiout
->redirect (mi
->event_channel
);
845 scoped_restore restore_uiout
846 = make_scoped_restore (¤t_uiout
, mi_uiout
);
848 print_breakpoint (bp
);
850 CATCH (ex
, RETURN_MASK_ALL
)
852 exception_print (gdb_stderr
, ex
);
856 mi_uiout
->redirect (NULL
);
859 /* Emit notification about a created breakpoint. */
862 mi_breakpoint_created (struct breakpoint
*b
)
864 if (mi_suppress_notification
.breakpoint
)
870 SWITCH_THRU_ALL_UIS ()
872 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
877 target_terminal::scoped_restore_terminal_state term_state
;
878 target_terminal::ours_for_output ();
880 fprintf_unfiltered (mi
->event_channel
,
881 "breakpoint-created");
882 mi_print_breakpoint_for_event (mi
, b
);
884 gdb_flush (mi
->event_channel
);
888 /* Emit notification about deleted breakpoint. */
891 mi_breakpoint_deleted (struct breakpoint
*b
)
893 if (mi_suppress_notification
.breakpoint
)
899 SWITCH_THRU_ALL_UIS ()
901 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
906 target_terminal::scoped_restore_terminal_state term_state
;
907 target_terminal::ours_for_output ();
909 fprintf_unfiltered (mi
->event_channel
, "breakpoint-deleted,id=\"%d\"",
912 gdb_flush (mi
->event_channel
);
916 /* Emit notification about modified breakpoint. */
919 mi_breakpoint_modified (struct breakpoint
*b
)
921 if (mi_suppress_notification
.breakpoint
)
927 SWITCH_THRU_ALL_UIS ()
929 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
934 target_terminal::scoped_restore_terminal_state term_state
;
935 target_terminal::ours_for_output ();
936 fprintf_unfiltered (mi
->event_channel
,
937 "breakpoint-modified");
938 mi_print_breakpoint_for_event (mi
, b
);
940 gdb_flush (mi
->event_channel
);
945 mi_output_running_pid (struct thread_info
*info
, void *arg
)
947 ptid_t
*ptid
= (ptid_t
*) arg
;
949 SWITCH_THRU_ALL_UIS ()
951 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
956 if (ptid_get_pid (*ptid
) == ptid_get_pid (info
->ptid
))
957 fprintf_unfiltered (mi
->raw_stdout
,
958 "*running,thread-id=\"%d\"\n",
966 mi_inferior_count (struct inferior
*inf
, void *arg
)
970 int *count_p
= (int *) arg
;
978 mi_on_resume_1 (struct mi_interp
*mi
, ptid_t ptid
)
980 /* To cater for older frontends, emit ^running, but do it only once
981 per each command. We do it here, since at this point we know
982 that the target was successfully resumed, and in non-async mode,
983 we won't return back to MI interpreter code until the target
984 is done running, so delaying the output of "^running" until then
985 will make it impossible for frontend to know what's going on.
987 In future (MI3), we'll be outputting "^done" here. */
988 if (!running_result_record_printed
&& mi_proceeded
)
990 fprintf_unfiltered (mi
->raw_stdout
, "%s^running\n",
991 current_token
? current_token
: "");
994 if (ptid_get_pid (ptid
) == -1)
995 fprintf_unfiltered (mi
->raw_stdout
, "*running,thread-id=\"all\"\n");
996 else if (ptid_is_pid (ptid
))
1000 /* Backwards compatibility. If there's only one inferior,
1001 output "all", otherwise, output each resumed thread
1003 iterate_over_inferiors (mi_inferior_count
, &count
);
1006 fprintf_unfiltered (mi
->raw_stdout
, "*running,thread-id=\"all\"\n");
1008 iterate_over_threads (mi_output_running_pid
, &ptid
);
1012 struct thread_info
*ti
= find_thread_ptid (ptid
);
1015 fprintf_unfiltered (mi
->raw_stdout
, "*running,thread-id=\"%d\"\n",
1019 if (!running_result_record_printed
&& mi_proceeded
)
1021 running_result_record_printed
= 1;
1022 /* This is what gdb used to do historically -- printing prompt
1023 even if it cannot actually accept any input. This will be
1024 surely removed for MI3, and may be removed even earlier. */
1025 if (current_ui
->prompt_state
== PROMPT_BLOCKED
)
1026 fputs_unfiltered ("(gdb) \n", mi
->raw_stdout
);
1028 gdb_flush (mi
->raw_stdout
);
1032 mi_on_resume (ptid_t ptid
)
1034 struct thread_info
*tp
= NULL
;
1036 if (ptid_equal (ptid
, minus_one_ptid
) || ptid_is_pid (ptid
))
1037 tp
= inferior_thread ();
1039 tp
= find_thread_ptid (ptid
);
1041 /* Suppress output while calling an inferior function. */
1042 if (tp
->control
.in_infcall
)
1045 SWITCH_THRU_ALL_UIS ()
1047 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1052 target_terminal::scoped_restore_terminal_state term_state
;
1053 target_terminal::ours_for_output ();
1055 mi_on_resume_1 (mi
, ptid
);
1059 /* See mi-interp.h. */
1062 mi_output_solib_attribs (ui_out
*uiout
, struct so_list
*solib
)
1064 struct gdbarch
*gdbarch
= target_gdbarch ();
1066 uiout
->field_string ("id", solib
->so_original_name
);
1067 uiout
->field_string ("target-name", solib
->so_original_name
);
1068 uiout
->field_string ("host-name", solib
->so_name
);
1069 uiout
->field_int ("symbols-loaded", solib
->symbols_loaded
);
1070 if (!gdbarch_has_global_solist (target_gdbarch ()))
1071 uiout
->field_fmt ("thread-group", "i%d", current_inferior ()->num
);
1073 ui_out_emit_list
list_emitter (uiout
, "ranges");
1074 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1075 if (solib
->addr_high
!= 0)
1077 uiout
->field_core_addr ("from", gdbarch
, solib
->addr_low
);
1078 uiout
->field_core_addr ("to", gdbarch
, solib
->addr_high
);
1083 mi_solib_loaded (struct so_list
*solib
)
1085 SWITCH_THRU_ALL_UIS ()
1087 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1088 struct ui_out
*uiout
;
1093 uiout
= interp_ui_out (top_level_interpreter ());
1095 target_terminal::scoped_restore_terminal_state term_state
;
1096 target_terminal::ours_for_output ();
1098 fprintf_unfiltered (mi
->event_channel
, "library-loaded");
1100 uiout
->redirect (mi
->event_channel
);
1102 mi_output_solib_attribs (uiout
, solib
);
1104 uiout
->redirect (NULL
);
1106 gdb_flush (mi
->event_channel
);
1111 mi_solib_unloaded (struct so_list
*solib
)
1113 SWITCH_THRU_ALL_UIS ()
1115 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1116 struct ui_out
*uiout
;
1121 uiout
= interp_ui_out (top_level_interpreter ());
1123 target_terminal::scoped_restore_terminal_state term_state
;
1124 target_terminal::ours_for_output ();
1126 fprintf_unfiltered (mi
->event_channel
, "library-unloaded");
1128 uiout
->redirect (mi
->event_channel
);
1130 uiout
->field_string ("id", solib
->so_original_name
);
1131 uiout
->field_string ("target-name", solib
->so_original_name
);
1132 uiout
->field_string ("host-name", solib
->so_name
);
1133 if (!gdbarch_has_global_solist (target_gdbarch ()))
1135 uiout
->field_fmt ("thread-group", "i%d", current_inferior ()->num
);
1138 uiout
->redirect (NULL
);
1140 gdb_flush (mi
->event_channel
);
1144 /* Emit notification about the command parameter change. */
1147 mi_command_param_changed (const char *param
, const char *value
)
1149 if (mi_suppress_notification
.cmd_param_changed
)
1152 SWITCH_THRU_ALL_UIS ()
1154 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1155 struct ui_out
*mi_uiout
;
1160 mi_uiout
= interp_ui_out (top_level_interpreter ());
1162 target_terminal::scoped_restore_terminal_state term_state
;
1163 target_terminal::ours_for_output ();
1165 fprintf_unfiltered (mi
->event_channel
, "cmd-param-changed");
1167 mi_uiout
->redirect (mi
->event_channel
);
1169 mi_uiout
->field_string ("param", param
);
1170 mi_uiout
->field_string ("value", value
);
1172 mi_uiout
->redirect (NULL
);
1174 gdb_flush (mi
->event_channel
);
1178 /* Emit notification about the target memory change. */
1181 mi_memory_changed (struct inferior
*inferior
, CORE_ADDR memaddr
,
1182 ssize_t len
, const bfd_byte
*myaddr
)
1184 if (mi_suppress_notification
.memory
)
1187 SWITCH_THRU_ALL_UIS ()
1189 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1190 struct ui_out
*mi_uiout
;
1191 struct obj_section
*sec
;
1196 mi_uiout
= interp_ui_out (top_level_interpreter ());
1198 target_terminal::scoped_restore_terminal_state term_state
;
1199 target_terminal::ours_for_output ();
1201 fprintf_unfiltered (mi
->event_channel
, "memory-changed");
1203 mi_uiout
->redirect (mi
->event_channel
);
1205 mi_uiout
->field_fmt ("thread-group", "i%d", inferior
->num
);
1206 mi_uiout
->field_core_addr ("addr", target_gdbarch (), memaddr
);
1207 mi_uiout
->field_fmt ("len", "%s", hex_string (len
));
1209 /* Append 'type=code' into notification if MEMADDR falls in the range of
1210 sections contain code. */
1211 sec
= find_pc_section (memaddr
);
1212 if (sec
!= NULL
&& sec
->objfile
!= NULL
)
1214 flagword flags
= bfd_get_section_flags (sec
->objfile
->obfd
,
1215 sec
->the_bfd_section
);
1217 if (flags
& SEC_CODE
)
1218 mi_uiout
->field_string ("type", "code");
1221 mi_uiout
->redirect (NULL
);
1223 gdb_flush (mi
->event_channel
);
1227 /* Emit an event when the selection context (inferior, thread, frame)
1231 mi_user_selected_context_changed (user_selected_what selection
)
1233 struct thread_info
*tp
;
1235 /* Don't send an event if we're responding to an MI command. */
1236 if (mi_suppress_notification
.user_selected_context
)
1239 tp
= find_thread_ptid (inferior_ptid
);
1241 SWITCH_THRU_ALL_UIS ()
1243 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1244 struct ui_out
*mi_uiout
;
1249 mi_uiout
= interp_ui_out (top_level_interpreter ());
1251 mi_uiout
->redirect (mi
->event_channel
);
1252 ui_out_redirect_pop
redirect_popper (mi_uiout
);
1254 target_terminal::scoped_restore_terminal_state term_state
;
1255 target_terminal::ours_for_output ();
1257 if (selection
& USER_SELECTED_INFERIOR
)
1258 print_selected_inferior (mi
->cli_uiout
);
1261 && (selection
& (USER_SELECTED_THREAD
| USER_SELECTED_FRAME
)))
1263 print_selected_thread_frame (mi
->cli_uiout
, selection
);
1265 fprintf_unfiltered (mi
->event_channel
,
1266 "thread-selected,id=\"%d\"",
1269 if (tp
->state
!= THREAD_RUNNING
)
1271 if (has_stack_frames ())
1272 print_stack_frame_to_uiout (mi_uiout
, get_selected_frame (NULL
),
1277 gdb_flush (mi
->event_channel
);
1282 report_initial_inferior (struct inferior
*inf
, void *closure
)
1284 /* This function is called from mi_interpreter_init, and since
1285 mi_inferior_added assumes that inferior is fully initialized
1286 and top_level_interpreter_data is set, we cannot call
1288 struct mi_interp
*mi
= (struct mi_interp
*) closure
;
1290 target_terminal::scoped_restore_terminal_state term_state
;
1291 target_terminal::ours_for_output ();
1293 fprintf_unfiltered (mi
->event_channel
,
1294 "thread-group-added,id=\"i%d\"",
1296 gdb_flush (mi
->event_channel
);
1302 mi_interp::interp_ui_out ()
1304 return this->mi_uiout
;
1307 /* Do MI-specific logging actions; save raw_stdout, and change all
1308 the consoles to use the supplied ui-file(s). */
1311 mi_interp::set_logging (ui_file_up logfile
, bool logging_redirect
)
1313 struct mi_interp
*mi
= this;
1315 if (logfile
!= NULL
)
1317 mi
->saved_raw_stdout
= mi
->raw_stdout
;
1318 mi
->raw_stdout
= make_logging_output (mi
->raw_stdout
,
1319 std::move (logfile
),
1325 delete mi
->raw_stdout
;
1326 mi
->raw_stdout
= mi
->saved_raw_stdout
;
1327 mi
->saved_raw_stdout
= NULL
;
1330 mi
->out
->set_raw (mi
->raw_stdout
);
1331 mi
->err
->set_raw (mi
->raw_stdout
);
1332 mi
->log
->set_raw (mi
->raw_stdout
);
1333 mi
->targ
->set_raw (mi
->raw_stdout
);
1334 mi
->event_channel
->set_raw (mi
->raw_stdout
);
1337 /* Factory for MI interpreters. */
1339 static struct interp
*
1340 mi_interp_factory (const char *name
)
1342 return new mi_interp (name
);
1346 _initialize_mi_interp (void)
1348 /* The various interpreter levels. */
1349 interp_factory_register (INTERP_MI1
, mi_interp_factory
);
1350 interp_factory_register (INTERP_MI2
, mi_interp_factory
);
1351 interp_factory_register (INTERP_MI3
, mi_interp_factory
);
1352 interp_factory_register (INTERP_MI
, mi_interp_factory
);
1354 gdb::observers::signal_received
.attach (mi_on_signal_received
);
1355 gdb::observers::end_stepping_range
.attach (mi_on_end_stepping_range
);
1356 gdb::observers::signal_exited
.attach (mi_on_signal_exited
);
1357 gdb::observers::exited
.attach (mi_on_exited
);
1358 gdb::observers::no_history
.attach (mi_on_no_history
);
1359 gdb::observers::new_thread
.attach (mi_new_thread
);
1360 gdb::observers::thread_exit
.attach (mi_thread_exit
);
1361 gdb::observers::inferior_added
.attach (mi_inferior_added
);
1362 gdb::observers::inferior_appeared
.attach (mi_inferior_appeared
);
1363 gdb::observers::inferior_exit
.attach (mi_inferior_exit
);
1364 gdb::observers::inferior_removed
.attach (mi_inferior_removed
);
1365 gdb::observers::record_changed
.attach (mi_record_changed
);
1366 gdb::observers::normal_stop
.attach (mi_on_normal_stop
);
1367 gdb::observers::target_resumed
.attach (mi_on_resume
);
1368 gdb::observers::solib_loaded
.attach (mi_solib_loaded
);
1369 gdb::observers::solib_unloaded
.attach (mi_solib_unloaded
);
1370 gdb::observers::about_to_proceed
.attach (mi_about_to_proceed
);
1371 gdb::observers::traceframe_changed
.attach (mi_traceframe_changed
);
1372 gdb::observers::tsv_created
.attach (mi_tsv_created
);
1373 gdb::observers::tsv_deleted
.attach (mi_tsv_deleted
);
1374 gdb::observers::tsv_modified
.attach (mi_tsv_modified
);
1375 gdb::observers::breakpoint_created
.attach (mi_breakpoint_created
);
1376 gdb::observers::breakpoint_deleted
.attach (mi_breakpoint_deleted
);
1377 gdb::observers::breakpoint_modified
.attach (mi_breakpoint_modified
);
1378 gdb::observers::command_param_changed
.attach (mi_command_param_changed
);
1379 gdb::observers::memory_changed
.attach (mi_memory_changed
);
1380 gdb::observers::sync_execution_done
.attach (mi_on_sync_execution_done
);
1381 gdb::observers::user_selected_context_changed
.attach
1382 (mi_user_selected_context_changed
);