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;
118 /* Store the current output channel, so that we can create a console
119 channel that encapsulates and prefixes all gdb_output-type bits
120 coming from the rest of the debugger. */
121 mi
->raw_stdout
= gdb_stdout
;
123 /* Create MI console channels, each with a different prefix so they
124 can be distinguished. */
125 mi
->out
= new mi_console_file (mi
->raw_stdout
, "~", '"');
126 mi
->err
= new mi_console_file (mi
->raw_stdout
, "&", '"');
128 mi
->targ
= new mi_console_file (mi
->raw_stdout
, "@", '"');
129 mi
->event_channel
= new mi_console_file (mi
->raw_stdout
, "=", 0);
131 /* INTERP_MI selects the most recent released version. "mi2" was
132 released as part of GDB 6.0. */
133 if (strcmp (name
, INTERP_MI
) == 0)
135 else if (strcmp (name
, INTERP_MI1
) == 0)
137 else if (strcmp (name
, INTERP_MI2
) == 0)
139 else if (strcmp (name
, INTERP_MI3
) == 0)
142 gdb_assert_not_reached ("unhandled MI version");
144 mi
->mi_uiout
= mi_out_new (mi_version
);
145 mi
->cli_uiout
= cli_out_new (mi
->out
);
149 /* The initial inferior is created before this function is
150 called, so we need to report it explicitly. Use iteration in
151 case future version of GDB creates more than one inferior
153 iterate_over_inferiors (report_initial_inferior
, mi
);
160 struct mi_interp
*mi
= this;
161 struct ui
*ui
= current_ui
;
163 /* As per hack note in mi_interpreter_init, swap in the output
165 gdb_setup_readline (0);
167 ui
->call_readline
= gdb_readline_no_editing_callback
;
168 ui
->input_handler
= mi_execute_command_input_handler
;
170 gdb_stdout
= mi
->out
;
171 /* Route error and log output through the MI. */
172 gdb_stderr
= mi
->err
;
173 gdb_stdlog
= mi
->log
;
174 /* Route target output through the MI. */
175 gdb_stdtarg
= mi
->targ
;
176 /* Route target error through the MI as well. */
177 gdb_stdtargerr
= mi
->targ
;
179 /* Replace all the hooks that we know about. There really needs to
180 be a better way of doing this... */
181 clear_interpreter_hooks ();
183 deprecated_show_load_progress
= mi_load_progress
;
187 mi_interp::suspend ()
189 gdb_disable_readline ();
193 mi_interp::exec (const char *command
)
195 mi_execute_command_wrapper (command
);
196 return exception_none
;
200 mi_cmd_interpreter_exec (const char *command
, char **argv
, int argc
)
202 struct interp
*interp_to_use
;
206 error (_("-interpreter-exec: "
207 "Usage: -interpreter-exec interp command"));
209 interp_to_use
= interp_lookup (current_ui
, argv
[0]);
210 if (interp_to_use
== NULL
)
211 error (_("-interpreter-exec: could not find interpreter \"%s\""),
214 /* Note that unlike the CLI version of this command, we don't
215 actually set INTERP_TO_USE as the current interpreter, as we
216 still want gdb_stdout, etc. to point at MI streams. */
218 /* Insert the MI out hooks, making sure to also call the
219 interpreter's hooks if it has any. */
220 /* KRS: We shouldn't need this... Events should be installed and
221 they should just ALWAYS fire something out down the MI
223 mi_insert_notify_hooks ();
225 /* Now run the code. */
227 std::string mi_error_message
;
228 for (i
= 1; i
< argc
; i
++)
230 struct gdb_exception e
= interp_exec (interp_to_use
, argv
[i
]);
234 mi_error_message
= e
.message
;
239 mi_remove_notify_hooks ();
241 if (!mi_error_message
.empty ())
242 error ("%s", mi_error_message
.c_str ());
245 /* This inserts a number of hooks that are meant to produce
246 async-notify ("=") MI messages while running commands in another
247 interpreter using mi_interpreter_exec. The canonical use for this
248 is to allow access to the gdb CLI interpreter from within the MI,
249 while still producing MI style output when actions in the CLI
250 command change GDB's state. */
253 mi_insert_notify_hooks (void)
255 deprecated_query_hook
= mi_interp_query_hook
;
259 mi_remove_notify_hooks (void)
261 deprecated_query_hook
= NULL
;
265 mi_interp_query_hook (const char *ctlstr
, va_list ap
)
271 mi_execute_command_wrapper (const char *cmd
)
273 struct ui
*ui
= current_ui
;
275 mi_execute_command (cmd
, ui
->instream
== ui
->stdin_stream
);
278 /* Observer for the synchronous_command_done notification. */
281 mi_on_sync_execution_done (void)
283 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
288 /* If MI is sync, then output the MI prompt now, indicating we're
289 ready for further input. */
291 display_mi_prompt (mi
);
294 /* mi_execute_command_wrapper wrapper suitable for INPUT_HANDLER. */
297 mi_execute_command_input_handler (char *cmd
)
299 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
300 struct ui
*ui
= current_ui
;
302 ui
->prompt_state
= PROMPT_NEEDED
;
304 mi_execute_command_wrapper (cmd
);
306 /* Print a prompt, indicating we're ready for further input, unless
307 we just started a synchronous command. In that case, we're about
308 to go back to the event loop and will output the prompt in the
309 'synchronous_command_done' observer when the target next
311 if (ui
->prompt_state
== PROMPT_NEEDED
)
312 display_mi_prompt (mi
);
316 mi_interp::pre_command_loop ()
318 struct mi_interp
*mi
= this;
320 /* Turn off 8 bit strings in quoted output. Any character with the
321 high bit set is printed using C's octal format. */
322 sevenbit_strings
= 1;
324 /* Tell the world that we're alive. */
325 display_mi_prompt (mi
);
329 mi_new_thread (struct thread_info
*t
)
331 struct inferior
*inf
= find_inferior_ptid (t
->ptid
);
335 SWITCH_THRU_ALL_UIS ()
337 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
342 target_terminal::scoped_restore_terminal_state term_state
;
343 target_terminal::ours_for_output ();
345 fprintf_unfiltered (mi
->event_channel
,
346 "thread-created,id=\"%d\",group-id=\"i%d\"",
347 t
->global_num
, inf
->num
);
348 gdb_flush (mi
->event_channel
);
353 mi_thread_exit (struct thread_info
*t
, int silent
)
358 SWITCH_THRU_ALL_UIS ()
360 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
365 target_terminal::scoped_restore_terminal_state term_state
;
366 target_terminal::ours_for_output ();
367 fprintf_unfiltered (mi
->event_channel
,
368 "thread-exited,id=\"%d\",group-id=\"i%d\"",
369 t
->global_num
, t
->inf
->num
);
370 gdb_flush (mi
->event_channel
);
374 /* Emit notification on changing the state of record. */
377 mi_record_changed (struct inferior
*inferior
, int started
, const char *method
,
380 SWITCH_THRU_ALL_UIS ()
382 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
387 target_terminal::scoped_restore_terminal_state term_state
;
388 target_terminal::ours_for_output ();
394 fprintf_unfiltered (mi
->event_channel
,
395 "record-started,thread-group=\"i%d\","
396 "method=\"%s\",format=\"%s\"",
397 inferior
->num
, method
, format
);
401 fprintf_unfiltered (mi
->event_channel
,
402 "record-started,thread-group=\"i%d\","
404 inferior
->num
, method
);
409 fprintf_unfiltered (mi
->event_channel
,
410 "record-stopped,thread-group=\"i%d\"",
414 gdb_flush (mi
->event_channel
);
419 mi_inferior_added (struct inferior
*inf
)
421 SWITCH_THRU_ALL_UIS ()
423 struct interp
*interp
;
424 struct mi_interp
*mi
;
426 /* We'll be called once for the initial inferior, before the top
427 level interpreter is set. */
428 interp
= top_level_interpreter ();
432 mi
= as_mi_interp (interp
);
436 target_terminal::scoped_restore_terminal_state term_state
;
437 target_terminal::ours_for_output ();
439 fprintf_unfiltered (mi
->event_channel
,
440 "thread-group-added,id=\"i%d\"",
442 gdb_flush (mi
->event_channel
);
447 mi_inferior_appeared (struct inferior
*inf
)
449 SWITCH_THRU_ALL_UIS ()
451 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
456 target_terminal::scoped_restore_terminal_state term_state
;
457 target_terminal::ours_for_output ();
459 fprintf_unfiltered (mi
->event_channel
,
460 "thread-group-started,id=\"i%d\",pid=\"%d\"",
462 gdb_flush (mi
->event_channel
);
467 mi_inferior_exit (struct inferior
*inf
)
469 SWITCH_THRU_ALL_UIS ()
471 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
476 target_terminal::scoped_restore_terminal_state term_state
;
477 target_terminal::ours_for_output ();
479 if (inf
->has_exit_code
)
480 fprintf_unfiltered (mi
->event_channel
,
481 "thread-group-exited,id=\"i%d\",exit-code=\"%s\"",
482 inf
->num
, int_string (inf
->exit_code
, 8, 0, 0, 1));
484 fprintf_unfiltered (mi
->event_channel
,
485 "thread-group-exited,id=\"i%d\"", inf
->num
);
487 gdb_flush (mi
->event_channel
);
492 mi_inferior_removed (struct inferior
*inf
)
494 SWITCH_THRU_ALL_UIS ()
496 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
501 target_terminal::scoped_restore_terminal_state term_state
;
502 target_terminal::ours_for_output ();
504 fprintf_unfiltered (mi
->event_channel
,
505 "thread-group-removed,id=\"i%d\"",
507 gdb_flush (mi
->event_channel
);
511 /* Return the MI interpreter, if it is active -- either because it's
512 the top-level interpreter or the interpreter executing the current
513 command. Returns NULL if the MI interpreter is not being used. */
515 static struct mi_interp
*
516 find_mi_interp (void)
518 struct mi_interp
*mi
;
520 mi
= as_mi_interp (top_level_interpreter ());
524 mi
= as_mi_interp (command_interp ());
531 /* Observers for several run control events that print why the
532 inferior has stopped to both the the MI event channel and to the MI
533 console. If the MI interpreter is not active, print nothing. */
535 /* Observer for the signal_received notification. */
538 mi_on_signal_received (enum gdb_signal siggnal
)
540 SWITCH_THRU_ALL_UIS ()
542 struct mi_interp
*mi
= find_mi_interp ();
547 print_signal_received_reason (mi
->mi_uiout
, siggnal
);
548 print_signal_received_reason (mi
->cli_uiout
, siggnal
);
552 /* Observer for the end_stepping_range notification. */
555 mi_on_end_stepping_range (void)
557 SWITCH_THRU_ALL_UIS ()
559 struct mi_interp
*mi
= find_mi_interp ();
564 print_end_stepping_range_reason (mi
->mi_uiout
);
565 print_end_stepping_range_reason (mi
->cli_uiout
);
569 /* Observer for the signal_exited notification. */
572 mi_on_signal_exited (enum gdb_signal siggnal
)
574 SWITCH_THRU_ALL_UIS ()
576 struct mi_interp
*mi
= find_mi_interp ();
581 print_signal_exited_reason (mi
->mi_uiout
, siggnal
);
582 print_signal_exited_reason (mi
->cli_uiout
, siggnal
);
586 /* Observer for the exited notification. */
589 mi_on_exited (int exitstatus
)
591 SWITCH_THRU_ALL_UIS ()
593 struct mi_interp
*mi
= find_mi_interp ();
598 print_exited_reason (mi
->mi_uiout
, exitstatus
);
599 print_exited_reason (mi
->cli_uiout
, exitstatus
);
603 /* Observer for the no_history notification. */
606 mi_on_no_history (void)
608 SWITCH_THRU_ALL_UIS ()
610 struct mi_interp
*mi
= find_mi_interp ();
615 print_no_history_reason (mi
->mi_uiout
);
616 print_no_history_reason (mi
->cli_uiout
);
621 mi_on_normal_stop_1 (struct bpstats
*bs
, int print_frame
)
623 /* Since this can be called when CLI command is executing,
624 using cli interpreter, be sure to use MI uiout for output,
625 not the current one. */
626 struct ui_out
*mi_uiout
= top_level_interpreter ()->interp_ui_out ();
627 struct mi_interp
*mi
= (struct mi_interp
*) top_level_interpreter ();
631 struct thread_info
*tp
;
633 struct interp
*console_interp
;
635 tp
= inferior_thread ();
637 if (tp
->thread_fsm
!= NULL
638 && thread_fsm_finished_p (tp
->thread_fsm
))
640 enum async_reply_reason reason
;
642 reason
= thread_fsm_async_reply_reason (tp
->thread_fsm
);
643 mi_uiout
->field_string ("reason", async_reason_lookup (reason
));
645 print_stop_event (mi_uiout
);
647 console_interp
= interp_lookup (current_ui
, INTERP_CONSOLE
);
648 if (should_print_stop_to_console (console_interp
, tp
))
649 print_stop_event (mi
->cli_uiout
);
651 mi_uiout
->field_int ("thread-id", tp
->global_num
);
654 ui_out_emit_list
list_emitter (mi_uiout
, "stopped-threads");
656 mi_uiout
->field_int (NULL
, tp
->global_num
);
659 mi_uiout
->field_string ("stopped-threads", "all");
661 core
= target_core_of_thread (inferior_ptid
);
663 mi_uiout
->field_int ("core", core
);
666 fputs_unfiltered ("*stopped", mi
->raw_stdout
);
667 mi_out_put (mi_uiout
, mi
->raw_stdout
);
668 mi_out_rewind (mi_uiout
);
669 mi_print_timing_maybe (mi
->raw_stdout
);
670 fputs_unfiltered ("\n", mi
->raw_stdout
);
671 gdb_flush (mi
->raw_stdout
);
675 mi_on_normal_stop (struct bpstats
*bs
, int print_frame
)
677 SWITCH_THRU_ALL_UIS ()
679 if (as_mi_interp (top_level_interpreter ()) == NULL
)
682 mi_on_normal_stop_1 (bs
, print_frame
);
687 mi_about_to_proceed (void)
689 /* Suppress output while calling an inferior function. */
691 if (!ptid_equal (inferior_ptid
, null_ptid
))
693 struct thread_info
*tp
= inferior_thread ();
695 if (tp
->control
.in_infcall
)
702 /* When the element is non-zero, no MI notifications will be emitted in
703 response to the corresponding observers. */
705 struct mi_suppress_notification mi_suppress_notification
=
713 /* Emit notification on changing a traceframe. */
716 mi_traceframe_changed (int tfnum
, int tpnum
)
718 if (mi_suppress_notification
.traceframe
)
721 SWITCH_THRU_ALL_UIS ()
723 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
728 target_terminal::scoped_restore_terminal_state term_state
;
729 target_terminal::ours_for_output ();
732 fprintf_unfiltered (mi
->event_channel
, "traceframe-changed,"
733 "num=\"%d\",tracepoint=\"%d\"\n",
736 fprintf_unfiltered (mi
->event_channel
, "traceframe-changed,end");
738 gdb_flush (mi
->event_channel
);
742 /* Emit notification on creating a trace state variable. */
745 mi_tsv_created (const struct trace_state_variable
*tsv
)
747 SWITCH_THRU_ALL_UIS ()
749 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
754 target_terminal::scoped_restore_terminal_state term_state
;
755 target_terminal::ours_for_output ();
757 fprintf_unfiltered (mi
->event_channel
, "tsv-created,"
758 "name=\"%s\",initial=\"%s\"\n",
759 tsv
->name
.c_str (), plongest (tsv
->initial_value
));
761 gdb_flush (mi
->event_channel
);
765 /* Emit notification on deleting a trace state variable. */
768 mi_tsv_deleted (const struct trace_state_variable
*tsv
)
770 SWITCH_THRU_ALL_UIS ()
772 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
777 target_terminal::scoped_restore_terminal_state term_state
;
778 target_terminal::ours_for_output ();
781 fprintf_unfiltered (mi
->event_channel
, "tsv-deleted,"
782 "name=\"%s\"\n", tsv
->name
.c_str ());
784 fprintf_unfiltered (mi
->event_channel
, "tsv-deleted\n");
786 gdb_flush (mi
->event_channel
);
790 /* Emit notification on modifying a trace state variable. */
793 mi_tsv_modified (const struct trace_state_variable
*tsv
)
795 SWITCH_THRU_ALL_UIS ()
797 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
798 struct ui_out
*mi_uiout
;
803 mi_uiout
= top_level_interpreter ()->interp_ui_out ();
805 target_terminal::scoped_restore_terminal_state term_state
;
806 target_terminal::ours_for_output ();
808 fprintf_unfiltered (mi
->event_channel
,
811 mi_uiout
->redirect (mi
->event_channel
);
813 mi_uiout
->field_string ("name", tsv
->name
);
814 mi_uiout
->field_string ("initial",
815 plongest (tsv
->initial_value
));
816 if (tsv
->value_known
)
817 mi_uiout
->field_string ("current", plongest (tsv
->value
));
819 mi_uiout
->redirect (NULL
);
821 gdb_flush (mi
->event_channel
);
825 /* Print breakpoint BP on MI's event channel. */
828 mi_print_breakpoint_for_event (struct mi_interp
*mi
, breakpoint
*bp
)
830 ui_out
*mi_uiout
= mi
->interp_ui_out ();
832 /* We want the output from print_breakpoint to go to
833 mi->event_channel. One approach would be to just call
834 print_breakpoint, and then use mi_out_put to send the current
835 content of mi_uiout into mi->event_channel. However, that will
836 break if anything is output to mi_uiout prior to calling the
837 breakpoint_created notifications. So, we use
839 mi_uiout
->redirect (mi
->event_channel
);
843 scoped_restore restore_uiout
844 = make_scoped_restore (¤t_uiout
, mi_uiout
);
846 print_breakpoint (bp
);
848 CATCH (ex
, RETURN_MASK_ALL
)
850 exception_print (gdb_stderr
, ex
);
854 mi_uiout
->redirect (NULL
);
857 /* Emit notification about a created breakpoint. */
860 mi_breakpoint_created (struct breakpoint
*b
)
862 if (mi_suppress_notification
.breakpoint
)
868 SWITCH_THRU_ALL_UIS ()
870 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
875 target_terminal::scoped_restore_terminal_state term_state
;
876 target_terminal::ours_for_output ();
878 fprintf_unfiltered (mi
->event_channel
,
879 "breakpoint-created");
880 mi_print_breakpoint_for_event (mi
, b
);
882 gdb_flush (mi
->event_channel
);
886 /* Emit notification about deleted breakpoint. */
889 mi_breakpoint_deleted (struct breakpoint
*b
)
891 if (mi_suppress_notification
.breakpoint
)
897 SWITCH_THRU_ALL_UIS ()
899 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
904 target_terminal::scoped_restore_terminal_state term_state
;
905 target_terminal::ours_for_output ();
907 fprintf_unfiltered (mi
->event_channel
, "breakpoint-deleted,id=\"%d\"",
910 gdb_flush (mi
->event_channel
);
914 /* Emit notification about modified breakpoint. */
917 mi_breakpoint_modified (struct breakpoint
*b
)
919 if (mi_suppress_notification
.breakpoint
)
925 SWITCH_THRU_ALL_UIS ()
927 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
932 target_terminal::scoped_restore_terminal_state term_state
;
933 target_terminal::ours_for_output ();
934 fprintf_unfiltered (mi
->event_channel
,
935 "breakpoint-modified");
936 mi_print_breakpoint_for_event (mi
, b
);
938 gdb_flush (mi
->event_channel
);
943 mi_output_running_pid (struct thread_info
*info
, void *arg
)
945 ptid_t
*ptid
= (ptid_t
*) arg
;
947 SWITCH_THRU_ALL_UIS ()
949 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
954 if (ptid_get_pid (*ptid
) == ptid_get_pid (info
->ptid
))
955 fprintf_unfiltered (mi
->raw_stdout
,
956 "*running,thread-id=\"%d\"\n",
964 mi_inferior_count (struct inferior
*inf
, void *arg
)
968 int *count_p
= (int *) arg
;
976 mi_on_resume_1 (struct mi_interp
*mi
, ptid_t ptid
)
978 /* To cater for older frontends, emit ^running, but do it only once
979 per each command. We do it here, since at this point we know
980 that the target was successfully resumed, and in non-async mode,
981 we won't return back to MI interpreter code until the target
982 is done running, so delaying the output of "^running" until then
983 will make it impossible for frontend to know what's going on.
985 In future (MI3), we'll be outputting "^done" here. */
986 if (!running_result_record_printed
&& mi_proceeded
)
988 fprintf_unfiltered (mi
->raw_stdout
, "%s^running\n",
989 current_token
? current_token
: "");
992 if (ptid_get_pid (ptid
) == -1)
993 fprintf_unfiltered (mi
->raw_stdout
, "*running,thread-id=\"all\"\n");
994 else if (ptid_is_pid (ptid
))
998 /* Backwards compatibility. If there's only one inferior,
999 output "all", otherwise, output each resumed thread
1001 iterate_over_inferiors (mi_inferior_count
, &count
);
1004 fprintf_unfiltered (mi
->raw_stdout
, "*running,thread-id=\"all\"\n");
1006 iterate_over_threads (mi_output_running_pid
, &ptid
);
1010 struct thread_info
*ti
= find_thread_ptid (ptid
);
1013 fprintf_unfiltered (mi
->raw_stdout
, "*running,thread-id=\"%d\"\n",
1017 if (!running_result_record_printed
&& mi_proceeded
)
1019 running_result_record_printed
= 1;
1020 /* This is what gdb used to do historically -- printing prompt
1021 even if it cannot actually accept any input. This will be
1022 surely removed for MI3, and may be removed even earlier. */
1023 if (current_ui
->prompt_state
== PROMPT_BLOCKED
)
1024 fputs_unfiltered ("(gdb) \n", mi
->raw_stdout
);
1026 gdb_flush (mi
->raw_stdout
);
1030 mi_on_resume (ptid_t ptid
)
1032 struct thread_info
*tp
= NULL
;
1034 if (ptid_equal (ptid
, minus_one_ptid
) || ptid_is_pid (ptid
))
1035 tp
= inferior_thread ();
1037 tp
= find_thread_ptid (ptid
);
1039 /* Suppress output while calling an inferior function. */
1040 if (tp
->control
.in_infcall
)
1043 SWITCH_THRU_ALL_UIS ()
1045 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1050 target_terminal::scoped_restore_terminal_state term_state
;
1051 target_terminal::ours_for_output ();
1053 mi_on_resume_1 (mi
, ptid
);
1057 /* See mi-interp.h. */
1060 mi_output_solib_attribs (ui_out
*uiout
, struct so_list
*solib
)
1062 struct gdbarch
*gdbarch
= target_gdbarch ();
1064 uiout
->field_string ("id", solib
->so_original_name
);
1065 uiout
->field_string ("target-name", solib
->so_original_name
);
1066 uiout
->field_string ("host-name", solib
->so_name
);
1067 uiout
->field_int ("symbols-loaded", solib
->symbols_loaded
);
1068 if (!gdbarch_has_global_solist (target_gdbarch ()))
1069 uiout
->field_fmt ("thread-group", "i%d", current_inferior ()->num
);
1071 ui_out_emit_list
list_emitter (uiout
, "ranges");
1072 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1073 if (solib
->addr_high
!= 0)
1075 uiout
->field_core_addr ("from", gdbarch
, solib
->addr_low
);
1076 uiout
->field_core_addr ("to", gdbarch
, solib
->addr_high
);
1081 mi_solib_loaded (struct so_list
*solib
)
1083 SWITCH_THRU_ALL_UIS ()
1085 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1086 struct ui_out
*uiout
;
1091 uiout
= top_level_interpreter ()->interp_ui_out ();
1093 target_terminal::scoped_restore_terminal_state term_state
;
1094 target_terminal::ours_for_output ();
1096 fprintf_unfiltered (mi
->event_channel
, "library-loaded");
1098 uiout
->redirect (mi
->event_channel
);
1100 mi_output_solib_attribs (uiout
, solib
);
1102 uiout
->redirect (NULL
);
1104 gdb_flush (mi
->event_channel
);
1109 mi_solib_unloaded (struct so_list
*solib
)
1111 SWITCH_THRU_ALL_UIS ()
1113 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1114 struct ui_out
*uiout
;
1119 uiout
= top_level_interpreter ()->interp_ui_out ();
1121 target_terminal::scoped_restore_terminal_state term_state
;
1122 target_terminal::ours_for_output ();
1124 fprintf_unfiltered (mi
->event_channel
, "library-unloaded");
1126 uiout
->redirect (mi
->event_channel
);
1128 uiout
->field_string ("id", solib
->so_original_name
);
1129 uiout
->field_string ("target-name", solib
->so_original_name
);
1130 uiout
->field_string ("host-name", solib
->so_name
);
1131 if (!gdbarch_has_global_solist (target_gdbarch ()))
1133 uiout
->field_fmt ("thread-group", "i%d", current_inferior ()->num
);
1136 uiout
->redirect (NULL
);
1138 gdb_flush (mi
->event_channel
);
1142 /* Emit notification about the command parameter change. */
1145 mi_command_param_changed (const char *param
, const char *value
)
1147 if (mi_suppress_notification
.cmd_param_changed
)
1150 SWITCH_THRU_ALL_UIS ()
1152 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1153 struct ui_out
*mi_uiout
;
1158 mi_uiout
= top_level_interpreter ()->interp_ui_out ();
1160 target_terminal::scoped_restore_terminal_state term_state
;
1161 target_terminal::ours_for_output ();
1163 fprintf_unfiltered (mi
->event_channel
, "cmd-param-changed");
1165 mi_uiout
->redirect (mi
->event_channel
);
1167 mi_uiout
->field_string ("param", param
);
1168 mi_uiout
->field_string ("value", value
);
1170 mi_uiout
->redirect (NULL
);
1172 gdb_flush (mi
->event_channel
);
1176 /* Emit notification about the target memory change. */
1179 mi_memory_changed (struct inferior
*inferior
, CORE_ADDR memaddr
,
1180 ssize_t len
, const bfd_byte
*myaddr
)
1182 if (mi_suppress_notification
.memory
)
1185 SWITCH_THRU_ALL_UIS ()
1187 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1188 struct ui_out
*mi_uiout
;
1189 struct obj_section
*sec
;
1194 mi_uiout
= top_level_interpreter ()->interp_ui_out ();
1196 target_terminal::scoped_restore_terminal_state term_state
;
1197 target_terminal::ours_for_output ();
1199 fprintf_unfiltered (mi
->event_channel
, "memory-changed");
1201 mi_uiout
->redirect (mi
->event_channel
);
1203 mi_uiout
->field_fmt ("thread-group", "i%d", inferior
->num
);
1204 mi_uiout
->field_core_addr ("addr", target_gdbarch (), memaddr
);
1205 mi_uiout
->field_fmt ("len", "%s", hex_string (len
));
1207 /* Append 'type=code' into notification if MEMADDR falls in the range of
1208 sections contain code. */
1209 sec
= find_pc_section (memaddr
);
1210 if (sec
!= NULL
&& sec
->objfile
!= NULL
)
1212 flagword flags
= bfd_get_section_flags (sec
->objfile
->obfd
,
1213 sec
->the_bfd_section
);
1215 if (flags
& SEC_CODE
)
1216 mi_uiout
->field_string ("type", "code");
1219 mi_uiout
->redirect (NULL
);
1221 gdb_flush (mi
->event_channel
);
1225 /* Emit an event when the selection context (inferior, thread, frame)
1229 mi_user_selected_context_changed (user_selected_what selection
)
1231 struct thread_info
*tp
;
1233 /* Don't send an event if we're responding to an MI command. */
1234 if (mi_suppress_notification
.user_selected_context
)
1237 tp
= find_thread_ptid (inferior_ptid
);
1239 SWITCH_THRU_ALL_UIS ()
1241 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1242 struct ui_out
*mi_uiout
;
1247 mi_uiout
= top_level_interpreter ()->interp_ui_out ();
1249 mi_uiout
->redirect (mi
->event_channel
);
1250 ui_out_redirect_pop
redirect_popper (mi_uiout
);
1252 target_terminal::scoped_restore_terminal_state term_state
;
1253 target_terminal::ours_for_output ();
1255 if (selection
& USER_SELECTED_INFERIOR
)
1256 print_selected_inferior (mi
->cli_uiout
);
1259 && (selection
& (USER_SELECTED_THREAD
| USER_SELECTED_FRAME
)))
1261 print_selected_thread_frame (mi
->cli_uiout
, selection
);
1263 fprintf_unfiltered (mi
->event_channel
,
1264 "thread-selected,id=\"%d\"",
1267 if (tp
->state
!= THREAD_RUNNING
)
1269 if (has_stack_frames ())
1270 print_stack_frame_to_uiout (mi_uiout
, get_selected_frame (NULL
),
1275 gdb_flush (mi
->event_channel
);
1280 report_initial_inferior (struct inferior
*inf
, void *closure
)
1282 /* This function is called from mi_interpreter_init, and since
1283 mi_inferior_added assumes that inferior is fully initialized
1284 and top_level_interpreter_data is set, we cannot call
1286 struct mi_interp
*mi
= (struct mi_interp
*) closure
;
1288 target_terminal::scoped_restore_terminal_state term_state
;
1289 target_terminal::ours_for_output ();
1291 fprintf_unfiltered (mi
->event_channel
,
1292 "thread-group-added,id=\"i%d\"",
1294 gdb_flush (mi
->event_channel
);
1300 mi_interp::interp_ui_out ()
1302 return this->mi_uiout
;
1305 /* Do MI-specific logging actions; save raw_stdout, and change all
1306 the consoles to use the supplied ui-file(s). */
1309 mi_interp::set_logging (ui_file_up logfile
, bool logging_redirect
)
1311 struct mi_interp
*mi
= this;
1313 if (logfile
!= NULL
)
1315 mi
->saved_raw_stdout
= mi
->raw_stdout
;
1316 mi
->raw_stdout
= make_logging_output (mi
->raw_stdout
,
1317 std::move (logfile
),
1323 delete mi
->raw_stdout
;
1324 mi
->raw_stdout
= mi
->saved_raw_stdout
;
1325 mi
->saved_raw_stdout
= NULL
;
1328 mi
->out
->set_raw (mi
->raw_stdout
);
1329 mi
->err
->set_raw (mi
->raw_stdout
);
1330 mi
->log
->set_raw (mi
->raw_stdout
);
1331 mi
->targ
->set_raw (mi
->raw_stdout
);
1332 mi
->event_channel
->set_raw (mi
->raw_stdout
);
1335 /* Factory for MI interpreters. */
1337 static struct interp
*
1338 mi_interp_factory (const char *name
)
1340 return new mi_interp (name
);
1344 _initialize_mi_interp (void)
1346 /* The various interpreter levels. */
1347 interp_factory_register (INTERP_MI1
, mi_interp_factory
);
1348 interp_factory_register (INTERP_MI2
, mi_interp_factory
);
1349 interp_factory_register (INTERP_MI3
, mi_interp_factory
);
1350 interp_factory_register (INTERP_MI
, mi_interp_factory
);
1352 gdb::observers::signal_received
.attach (mi_on_signal_received
);
1353 gdb::observers::end_stepping_range
.attach (mi_on_end_stepping_range
);
1354 gdb::observers::signal_exited
.attach (mi_on_signal_exited
);
1355 gdb::observers::exited
.attach (mi_on_exited
);
1356 gdb::observers::no_history
.attach (mi_on_no_history
);
1357 gdb::observers::new_thread
.attach (mi_new_thread
);
1358 gdb::observers::thread_exit
.attach (mi_thread_exit
);
1359 gdb::observers::inferior_added
.attach (mi_inferior_added
);
1360 gdb::observers::inferior_appeared
.attach (mi_inferior_appeared
);
1361 gdb::observers::inferior_exit
.attach (mi_inferior_exit
);
1362 gdb::observers::inferior_removed
.attach (mi_inferior_removed
);
1363 gdb::observers::record_changed
.attach (mi_record_changed
);
1364 gdb::observers::normal_stop
.attach (mi_on_normal_stop
);
1365 gdb::observers::target_resumed
.attach (mi_on_resume
);
1366 gdb::observers::solib_loaded
.attach (mi_solib_loaded
);
1367 gdb::observers::solib_unloaded
.attach (mi_solib_unloaded
);
1368 gdb::observers::about_to_proceed
.attach (mi_about_to_proceed
);
1369 gdb::observers::traceframe_changed
.attach (mi_traceframe_changed
);
1370 gdb::observers::tsv_created
.attach (mi_tsv_created
);
1371 gdb::observers::tsv_deleted
.attach (mi_tsv_deleted
);
1372 gdb::observers::tsv_modified
.attach (mi_tsv_modified
);
1373 gdb::observers::breakpoint_created
.attach (mi_breakpoint_created
);
1374 gdb::observers::breakpoint_deleted
.attach (mi_breakpoint_deleted
);
1375 gdb::observers::breakpoint_modified
.attach (mi_breakpoint_modified
);
1376 gdb::observers::command_param_changed
.attach (mi_command_param_changed
);
1377 gdb::observers::memory_changed
.attach (mi_memory_changed
);
1378 gdb::observers::sync_execution_done
.attach (mi_on_sync_execution_done
);
1379 gdb::observers::user_selected_context_changed
.attach
1380 (mi_user_selected_context_changed
);