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 SWITCH_THRU_ALL_UIS ()
333 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
338 target_terminal::scoped_restore_terminal_state term_state
;
339 target_terminal::ours_for_output ();
341 fprintf_unfiltered (mi
->event_channel
,
342 "thread-created,id=\"%d\",group-id=\"i%d\"",
343 t
->global_num
, t
->inf
->num
);
344 gdb_flush (mi
->event_channel
);
349 mi_thread_exit (struct thread_info
*t
, int silent
)
354 SWITCH_THRU_ALL_UIS ()
356 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
361 target_terminal::scoped_restore_terminal_state term_state
;
362 target_terminal::ours_for_output ();
363 fprintf_unfiltered (mi
->event_channel
,
364 "thread-exited,id=\"%d\",group-id=\"i%d\"",
365 t
->global_num
, t
->inf
->num
);
366 gdb_flush (mi
->event_channel
);
370 /* Emit notification on changing the state of record. */
373 mi_record_changed (struct inferior
*inferior
, int started
, const char *method
,
376 SWITCH_THRU_ALL_UIS ()
378 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
383 target_terminal::scoped_restore_terminal_state term_state
;
384 target_terminal::ours_for_output ();
390 fprintf_unfiltered (mi
->event_channel
,
391 "record-started,thread-group=\"i%d\","
392 "method=\"%s\",format=\"%s\"",
393 inferior
->num
, method
, format
);
397 fprintf_unfiltered (mi
->event_channel
,
398 "record-started,thread-group=\"i%d\","
400 inferior
->num
, method
);
405 fprintf_unfiltered (mi
->event_channel
,
406 "record-stopped,thread-group=\"i%d\"",
410 gdb_flush (mi
->event_channel
);
415 mi_inferior_added (struct inferior
*inf
)
417 SWITCH_THRU_ALL_UIS ()
419 struct interp
*interp
;
420 struct mi_interp
*mi
;
422 /* We'll be called once for the initial inferior, before the top
423 level interpreter is set. */
424 interp
= top_level_interpreter ();
428 mi
= as_mi_interp (interp
);
432 target_terminal::scoped_restore_terminal_state term_state
;
433 target_terminal::ours_for_output ();
435 fprintf_unfiltered (mi
->event_channel
,
436 "thread-group-added,id=\"i%d\"",
438 gdb_flush (mi
->event_channel
);
443 mi_inferior_appeared (struct inferior
*inf
)
445 SWITCH_THRU_ALL_UIS ()
447 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
452 target_terminal::scoped_restore_terminal_state term_state
;
453 target_terminal::ours_for_output ();
455 fprintf_unfiltered (mi
->event_channel
,
456 "thread-group-started,id=\"i%d\",pid=\"%d\"",
458 gdb_flush (mi
->event_channel
);
463 mi_inferior_exit (struct inferior
*inf
)
465 SWITCH_THRU_ALL_UIS ()
467 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
472 target_terminal::scoped_restore_terminal_state term_state
;
473 target_terminal::ours_for_output ();
475 if (inf
->has_exit_code
)
476 fprintf_unfiltered (mi
->event_channel
,
477 "thread-group-exited,id=\"i%d\",exit-code=\"%s\"",
478 inf
->num
, int_string (inf
->exit_code
, 8, 0, 0, 1));
480 fprintf_unfiltered (mi
->event_channel
,
481 "thread-group-exited,id=\"i%d\"", inf
->num
);
483 gdb_flush (mi
->event_channel
);
488 mi_inferior_removed (struct inferior
*inf
)
490 SWITCH_THRU_ALL_UIS ()
492 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
497 target_terminal::scoped_restore_terminal_state term_state
;
498 target_terminal::ours_for_output ();
500 fprintf_unfiltered (mi
->event_channel
,
501 "thread-group-removed,id=\"i%d\"",
503 gdb_flush (mi
->event_channel
);
507 /* Return the MI interpreter, if it is active -- either because it's
508 the top-level interpreter or the interpreter executing the current
509 command. Returns NULL if the MI interpreter is not being used. */
511 static struct mi_interp
*
512 find_mi_interp (void)
514 struct mi_interp
*mi
;
516 mi
= as_mi_interp (top_level_interpreter ());
520 mi
= as_mi_interp (command_interp ());
527 /* Observers for several run control events that print why the
528 inferior has stopped to both the the MI event channel and to the MI
529 console. If the MI interpreter is not active, print nothing. */
531 /* Observer for the signal_received notification. */
534 mi_on_signal_received (enum gdb_signal siggnal
)
536 SWITCH_THRU_ALL_UIS ()
538 struct mi_interp
*mi
= find_mi_interp ();
543 print_signal_received_reason (mi
->mi_uiout
, siggnal
);
544 print_signal_received_reason (mi
->cli_uiout
, siggnal
);
548 /* Observer for the end_stepping_range notification. */
551 mi_on_end_stepping_range (void)
553 SWITCH_THRU_ALL_UIS ()
555 struct mi_interp
*mi
= find_mi_interp ();
560 print_end_stepping_range_reason (mi
->mi_uiout
);
561 print_end_stepping_range_reason (mi
->cli_uiout
);
565 /* Observer for the signal_exited notification. */
568 mi_on_signal_exited (enum gdb_signal siggnal
)
570 SWITCH_THRU_ALL_UIS ()
572 struct mi_interp
*mi
= find_mi_interp ();
577 print_signal_exited_reason (mi
->mi_uiout
, siggnal
);
578 print_signal_exited_reason (mi
->cli_uiout
, siggnal
);
582 /* Observer for the exited notification. */
585 mi_on_exited (int exitstatus
)
587 SWITCH_THRU_ALL_UIS ()
589 struct mi_interp
*mi
= find_mi_interp ();
594 print_exited_reason (mi
->mi_uiout
, exitstatus
);
595 print_exited_reason (mi
->cli_uiout
, exitstatus
);
599 /* Observer for the no_history notification. */
602 mi_on_no_history (void)
604 SWITCH_THRU_ALL_UIS ()
606 struct mi_interp
*mi
= find_mi_interp ();
611 print_no_history_reason (mi
->mi_uiout
);
612 print_no_history_reason (mi
->cli_uiout
);
617 mi_on_normal_stop_1 (struct bpstats
*bs
, int print_frame
)
619 /* Since this can be called when CLI command is executing,
620 using cli interpreter, be sure to use MI uiout for output,
621 not the current one. */
622 struct ui_out
*mi_uiout
= top_level_interpreter ()->interp_ui_out ();
623 struct mi_interp
*mi
= (struct mi_interp
*) top_level_interpreter ();
627 struct thread_info
*tp
;
629 struct interp
*console_interp
;
631 tp
= inferior_thread ();
633 if (tp
->thread_fsm
!= NULL
634 && thread_fsm_finished_p (tp
->thread_fsm
))
636 enum async_reply_reason reason
;
638 reason
= thread_fsm_async_reply_reason (tp
->thread_fsm
);
639 mi_uiout
->field_string ("reason", async_reason_lookup (reason
));
641 print_stop_event (mi_uiout
);
643 console_interp
= interp_lookup (current_ui
, INTERP_CONSOLE
);
644 if (should_print_stop_to_console (console_interp
, tp
))
645 print_stop_event (mi
->cli_uiout
);
647 mi_uiout
->field_int ("thread-id", tp
->global_num
);
650 ui_out_emit_list
list_emitter (mi_uiout
, "stopped-threads");
652 mi_uiout
->field_int (NULL
, tp
->global_num
);
655 mi_uiout
->field_string ("stopped-threads", "all");
657 core
= target_core_of_thread (tp
->ptid
);
659 mi_uiout
->field_int ("core", core
);
662 fputs_unfiltered ("*stopped", mi
->raw_stdout
);
663 mi_out_put (mi_uiout
, mi
->raw_stdout
);
664 mi_out_rewind (mi_uiout
);
665 mi_print_timing_maybe (mi
->raw_stdout
);
666 fputs_unfiltered ("\n", mi
->raw_stdout
);
667 gdb_flush (mi
->raw_stdout
);
671 mi_on_normal_stop (struct bpstats
*bs
, int print_frame
)
673 SWITCH_THRU_ALL_UIS ()
675 if (as_mi_interp (top_level_interpreter ()) == NULL
)
678 mi_on_normal_stop_1 (bs
, print_frame
);
683 mi_about_to_proceed (void)
685 /* Suppress output while calling an inferior function. */
687 if (inferior_ptid
!= null_ptid
)
689 struct thread_info
*tp
= inferior_thread ();
691 if (tp
->control
.in_infcall
)
698 /* When the element is non-zero, no MI notifications will be emitted in
699 response to the corresponding observers. */
701 struct mi_suppress_notification mi_suppress_notification
=
709 /* Emit notification on changing a traceframe. */
712 mi_traceframe_changed (int tfnum
, int tpnum
)
714 if (mi_suppress_notification
.traceframe
)
717 SWITCH_THRU_ALL_UIS ()
719 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
724 target_terminal::scoped_restore_terminal_state term_state
;
725 target_terminal::ours_for_output ();
728 fprintf_unfiltered (mi
->event_channel
, "traceframe-changed,"
729 "num=\"%d\",tracepoint=\"%d\"\n",
732 fprintf_unfiltered (mi
->event_channel
, "traceframe-changed,end");
734 gdb_flush (mi
->event_channel
);
738 /* Emit notification on creating a trace state variable. */
741 mi_tsv_created (const struct trace_state_variable
*tsv
)
743 SWITCH_THRU_ALL_UIS ()
745 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
750 target_terminal::scoped_restore_terminal_state term_state
;
751 target_terminal::ours_for_output ();
753 fprintf_unfiltered (mi
->event_channel
, "tsv-created,"
754 "name=\"%s\",initial=\"%s\"\n",
755 tsv
->name
.c_str (), plongest (tsv
->initial_value
));
757 gdb_flush (mi
->event_channel
);
761 /* Emit notification on deleting a trace state variable. */
764 mi_tsv_deleted (const struct trace_state_variable
*tsv
)
766 SWITCH_THRU_ALL_UIS ()
768 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
773 target_terminal::scoped_restore_terminal_state term_state
;
774 target_terminal::ours_for_output ();
777 fprintf_unfiltered (mi
->event_channel
, "tsv-deleted,"
778 "name=\"%s\"\n", tsv
->name
.c_str ());
780 fprintf_unfiltered (mi
->event_channel
, "tsv-deleted\n");
782 gdb_flush (mi
->event_channel
);
786 /* Emit notification on modifying a trace state variable. */
789 mi_tsv_modified (const struct trace_state_variable
*tsv
)
791 SWITCH_THRU_ALL_UIS ()
793 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
794 struct ui_out
*mi_uiout
;
799 mi_uiout
= top_level_interpreter ()->interp_ui_out ();
801 target_terminal::scoped_restore_terminal_state term_state
;
802 target_terminal::ours_for_output ();
804 fprintf_unfiltered (mi
->event_channel
,
807 mi_uiout
->redirect (mi
->event_channel
);
809 mi_uiout
->field_string ("name", tsv
->name
);
810 mi_uiout
->field_string ("initial",
811 plongest (tsv
->initial_value
));
812 if (tsv
->value_known
)
813 mi_uiout
->field_string ("current", plongest (tsv
->value
));
815 mi_uiout
->redirect (NULL
);
817 gdb_flush (mi
->event_channel
);
821 /* Print breakpoint BP on MI's event channel. */
824 mi_print_breakpoint_for_event (struct mi_interp
*mi
, breakpoint
*bp
)
826 ui_out
*mi_uiout
= mi
->interp_ui_out ();
828 /* We want the output from print_breakpoint to go to
829 mi->event_channel. One approach would be to just call
830 print_breakpoint, and then use mi_out_put to send the current
831 content of mi_uiout into mi->event_channel. However, that will
832 break if anything is output to mi_uiout prior to calling the
833 breakpoint_created notifications. So, we use
835 mi_uiout
->redirect (mi
->event_channel
);
839 scoped_restore restore_uiout
840 = make_scoped_restore (¤t_uiout
, mi_uiout
);
842 print_breakpoint (bp
);
844 CATCH (ex
, RETURN_MASK_ALL
)
846 exception_print (gdb_stderr
, ex
);
850 mi_uiout
->redirect (NULL
);
853 /* Emit notification about a created breakpoint. */
856 mi_breakpoint_created (struct breakpoint
*b
)
858 if (mi_suppress_notification
.breakpoint
)
864 SWITCH_THRU_ALL_UIS ()
866 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
871 target_terminal::scoped_restore_terminal_state term_state
;
872 target_terminal::ours_for_output ();
874 fprintf_unfiltered (mi
->event_channel
,
875 "breakpoint-created");
876 mi_print_breakpoint_for_event (mi
, b
);
878 gdb_flush (mi
->event_channel
);
882 /* Emit notification about deleted breakpoint. */
885 mi_breakpoint_deleted (struct breakpoint
*b
)
887 if (mi_suppress_notification
.breakpoint
)
893 SWITCH_THRU_ALL_UIS ()
895 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
900 target_terminal::scoped_restore_terminal_state term_state
;
901 target_terminal::ours_for_output ();
903 fprintf_unfiltered (mi
->event_channel
, "breakpoint-deleted,id=\"%d\"",
906 gdb_flush (mi
->event_channel
);
910 /* Emit notification about modified breakpoint. */
913 mi_breakpoint_modified (struct breakpoint
*b
)
915 if (mi_suppress_notification
.breakpoint
)
921 SWITCH_THRU_ALL_UIS ()
923 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
928 target_terminal::scoped_restore_terminal_state term_state
;
929 target_terminal::ours_for_output ();
930 fprintf_unfiltered (mi
->event_channel
,
931 "breakpoint-modified");
932 mi_print_breakpoint_for_event (mi
, b
);
934 gdb_flush (mi
->event_channel
);
939 mi_output_running (struct thread_info
*thread
)
941 SWITCH_THRU_ALL_UIS ()
943 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
948 fprintf_unfiltered (mi
->raw_stdout
,
949 "*running,thread-id=\"%d\"\n",
954 /* Return true if there are multiple inferiors loaded. This is used
955 for backwards compatibility -- if there's only one inferior, output
956 "all", otherwise, output each resumed thread individually. */
959 multiple_inferiors_p ()
962 for (inferior
*inf ATTRIBUTE_UNUSED
: all_non_exited_inferiors ())
973 mi_on_resume_1 (struct mi_interp
*mi
, ptid_t ptid
)
975 /* To cater for older frontends, emit ^running, but do it only once
976 per each command. We do it here, since at this point we know
977 that the target was successfully resumed, and in non-async mode,
978 we won't return back to MI interpreter code until the target
979 is done running, so delaying the output of "^running" until then
980 will make it impossible for frontend to know what's going on.
982 In future (MI3), we'll be outputting "^done" here. */
983 if (!running_result_record_printed
&& mi_proceeded
)
985 fprintf_unfiltered (mi
->raw_stdout
, "%s^running\n",
986 current_token
? current_token
: "");
989 /* Backwards compatibility. If doing a wildcard resume and there's
990 only one inferior, output "all", otherwise, output each resumed
991 thread individually. */
992 if ((ptid
== minus_one_ptid
|| ptid
.is_pid ())
993 && !multiple_inferiors_p ())
994 fprintf_unfiltered (mi
->raw_stdout
, "*running,thread-id=\"all\"\n");
996 for (thread_info
*tp
: all_non_exited_threads (ptid
))
997 mi_output_running (tp
);
999 if (!running_result_record_printed
&& mi_proceeded
)
1001 running_result_record_printed
= 1;
1002 /* This is what gdb used to do historically -- printing prompt
1003 even if it cannot actually accept any input. This will be
1004 surely removed for MI3, and may be removed even earlier. */
1005 if (current_ui
->prompt_state
== PROMPT_BLOCKED
)
1006 fputs_unfiltered ("(gdb) \n", mi
->raw_stdout
);
1008 gdb_flush (mi
->raw_stdout
);
1012 mi_on_resume (ptid_t ptid
)
1014 struct thread_info
*tp
= NULL
;
1016 if (ptid
== minus_one_ptid
|| ptid
.is_pid ())
1017 tp
= inferior_thread ();
1019 tp
= find_thread_ptid (ptid
);
1021 /* Suppress output while calling an inferior function. */
1022 if (tp
->control
.in_infcall
)
1025 SWITCH_THRU_ALL_UIS ()
1027 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1032 target_terminal::scoped_restore_terminal_state term_state
;
1033 target_terminal::ours_for_output ();
1035 mi_on_resume_1 (mi
, ptid
);
1039 /* See mi-interp.h. */
1042 mi_output_solib_attribs (ui_out
*uiout
, struct so_list
*solib
)
1044 struct gdbarch
*gdbarch
= target_gdbarch ();
1046 uiout
->field_string ("id", solib
->so_original_name
);
1047 uiout
->field_string ("target-name", solib
->so_original_name
);
1048 uiout
->field_string ("host-name", solib
->so_name
);
1049 uiout
->field_int ("symbols-loaded", solib
->symbols_loaded
);
1050 if (!gdbarch_has_global_solist (target_gdbarch ()))
1051 uiout
->field_fmt ("thread-group", "i%d", current_inferior ()->num
);
1053 ui_out_emit_list
list_emitter (uiout
, "ranges");
1054 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1055 if (solib
->addr_high
!= 0)
1057 uiout
->field_core_addr ("from", gdbarch
, solib
->addr_low
);
1058 uiout
->field_core_addr ("to", gdbarch
, solib
->addr_high
);
1063 mi_solib_loaded (struct so_list
*solib
)
1065 SWITCH_THRU_ALL_UIS ()
1067 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1068 struct ui_out
*uiout
;
1073 uiout
= top_level_interpreter ()->interp_ui_out ();
1075 target_terminal::scoped_restore_terminal_state term_state
;
1076 target_terminal::ours_for_output ();
1078 fprintf_unfiltered (mi
->event_channel
, "library-loaded");
1080 uiout
->redirect (mi
->event_channel
);
1082 mi_output_solib_attribs (uiout
, solib
);
1084 uiout
->redirect (NULL
);
1086 gdb_flush (mi
->event_channel
);
1091 mi_solib_unloaded (struct so_list
*solib
)
1093 SWITCH_THRU_ALL_UIS ()
1095 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1096 struct ui_out
*uiout
;
1101 uiout
= top_level_interpreter ()->interp_ui_out ();
1103 target_terminal::scoped_restore_terminal_state term_state
;
1104 target_terminal::ours_for_output ();
1106 fprintf_unfiltered (mi
->event_channel
, "library-unloaded");
1108 uiout
->redirect (mi
->event_channel
);
1110 uiout
->field_string ("id", solib
->so_original_name
);
1111 uiout
->field_string ("target-name", solib
->so_original_name
);
1112 uiout
->field_string ("host-name", solib
->so_name
);
1113 if (!gdbarch_has_global_solist (target_gdbarch ()))
1115 uiout
->field_fmt ("thread-group", "i%d", current_inferior ()->num
);
1118 uiout
->redirect (NULL
);
1120 gdb_flush (mi
->event_channel
);
1124 /* Emit notification about the command parameter change. */
1127 mi_command_param_changed (const char *param
, const char *value
)
1129 if (mi_suppress_notification
.cmd_param_changed
)
1132 SWITCH_THRU_ALL_UIS ()
1134 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1135 struct ui_out
*mi_uiout
;
1140 mi_uiout
= top_level_interpreter ()->interp_ui_out ();
1142 target_terminal::scoped_restore_terminal_state term_state
;
1143 target_terminal::ours_for_output ();
1145 fprintf_unfiltered (mi
->event_channel
, "cmd-param-changed");
1147 mi_uiout
->redirect (mi
->event_channel
);
1149 mi_uiout
->field_string ("param", param
);
1150 mi_uiout
->field_string ("value", value
);
1152 mi_uiout
->redirect (NULL
);
1154 gdb_flush (mi
->event_channel
);
1158 /* Emit notification about the target memory change. */
1161 mi_memory_changed (struct inferior
*inferior
, CORE_ADDR memaddr
,
1162 ssize_t len
, const bfd_byte
*myaddr
)
1164 if (mi_suppress_notification
.memory
)
1167 SWITCH_THRU_ALL_UIS ()
1169 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1170 struct ui_out
*mi_uiout
;
1171 struct obj_section
*sec
;
1176 mi_uiout
= top_level_interpreter ()->interp_ui_out ();
1178 target_terminal::scoped_restore_terminal_state term_state
;
1179 target_terminal::ours_for_output ();
1181 fprintf_unfiltered (mi
->event_channel
, "memory-changed");
1183 mi_uiout
->redirect (mi
->event_channel
);
1185 mi_uiout
->field_fmt ("thread-group", "i%d", inferior
->num
);
1186 mi_uiout
->field_core_addr ("addr", target_gdbarch (), memaddr
);
1187 mi_uiout
->field_fmt ("len", "%s", hex_string (len
));
1189 /* Append 'type=code' into notification if MEMADDR falls in the range of
1190 sections contain code. */
1191 sec
= find_pc_section (memaddr
);
1192 if (sec
!= NULL
&& sec
->objfile
!= NULL
)
1194 flagword flags
= bfd_get_section_flags (sec
->objfile
->obfd
,
1195 sec
->the_bfd_section
);
1197 if (flags
& SEC_CODE
)
1198 mi_uiout
->field_string ("type", "code");
1201 mi_uiout
->redirect (NULL
);
1203 gdb_flush (mi
->event_channel
);
1207 /* Emit an event when the selection context (inferior, thread, frame)
1211 mi_user_selected_context_changed (user_selected_what selection
)
1213 struct thread_info
*tp
;
1215 /* Don't send an event if we're responding to an MI command. */
1216 if (mi_suppress_notification
.user_selected_context
)
1219 if (inferior_ptid
!= null_ptid
)
1220 tp
= inferior_thread ();
1224 SWITCH_THRU_ALL_UIS ()
1226 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1227 struct ui_out
*mi_uiout
;
1232 mi_uiout
= top_level_interpreter ()->interp_ui_out ();
1234 mi_uiout
->redirect (mi
->event_channel
);
1235 ui_out_redirect_pop
redirect_popper (mi_uiout
);
1237 target_terminal::scoped_restore_terminal_state term_state
;
1238 target_terminal::ours_for_output ();
1240 if (selection
& USER_SELECTED_INFERIOR
)
1241 print_selected_inferior (mi
->cli_uiout
);
1244 && (selection
& (USER_SELECTED_THREAD
| USER_SELECTED_FRAME
)))
1246 print_selected_thread_frame (mi
->cli_uiout
, selection
);
1248 fprintf_unfiltered (mi
->event_channel
,
1249 "thread-selected,id=\"%d\"",
1252 if (tp
->state
!= THREAD_RUNNING
)
1254 if (has_stack_frames ())
1255 print_stack_frame_to_uiout (mi_uiout
, get_selected_frame (NULL
),
1260 gdb_flush (mi
->event_channel
);
1265 report_initial_inferior (struct inferior
*inf
, void *closure
)
1267 /* This function is called from mi_interpreter_init, and since
1268 mi_inferior_added assumes that inferior is fully initialized
1269 and top_level_interpreter_data is set, we cannot call
1271 struct mi_interp
*mi
= (struct mi_interp
*) closure
;
1273 target_terminal::scoped_restore_terminal_state term_state
;
1274 target_terminal::ours_for_output ();
1276 fprintf_unfiltered (mi
->event_channel
,
1277 "thread-group-added,id=\"i%d\"",
1279 gdb_flush (mi
->event_channel
);
1285 mi_interp::interp_ui_out ()
1287 return this->mi_uiout
;
1290 /* Do MI-specific logging actions; save raw_stdout, and change all
1291 the consoles to use the supplied ui-file(s). */
1294 mi_interp::set_logging (ui_file_up logfile
, bool logging_redirect
)
1296 struct mi_interp
*mi
= this;
1298 if (logfile
!= NULL
)
1300 mi
->saved_raw_stdout
= mi
->raw_stdout
;
1301 mi
->raw_stdout
= make_logging_output (mi
->raw_stdout
,
1302 std::move (logfile
),
1308 delete mi
->raw_stdout
;
1309 mi
->raw_stdout
= mi
->saved_raw_stdout
;
1310 mi
->saved_raw_stdout
= NULL
;
1313 mi
->out
->set_raw (mi
->raw_stdout
);
1314 mi
->err
->set_raw (mi
->raw_stdout
);
1315 mi
->log
->set_raw (mi
->raw_stdout
);
1316 mi
->targ
->set_raw (mi
->raw_stdout
);
1317 mi
->event_channel
->set_raw (mi
->raw_stdout
);
1320 /* Factory for MI interpreters. */
1322 static struct interp
*
1323 mi_interp_factory (const char *name
)
1325 return new mi_interp (name
);
1329 _initialize_mi_interp (void)
1331 /* The various interpreter levels. */
1332 interp_factory_register (INTERP_MI1
, mi_interp_factory
);
1333 interp_factory_register (INTERP_MI2
, mi_interp_factory
);
1334 interp_factory_register (INTERP_MI3
, mi_interp_factory
);
1335 interp_factory_register (INTERP_MI
, mi_interp_factory
);
1337 gdb::observers::signal_received
.attach (mi_on_signal_received
);
1338 gdb::observers::end_stepping_range
.attach (mi_on_end_stepping_range
);
1339 gdb::observers::signal_exited
.attach (mi_on_signal_exited
);
1340 gdb::observers::exited
.attach (mi_on_exited
);
1341 gdb::observers::no_history
.attach (mi_on_no_history
);
1342 gdb::observers::new_thread
.attach (mi_new_thread
);
1343 gdb::observers::thread_exit
.attach (mi_thread_exit
);
1344 gdb::observers::inferior_added
.attach (mi_inferior_added
);
1345 gdb::observers::inferior_appeared
.attach (mi_inferior_appeared
);
1346 gdb::observers::inferior_exit
.attach (mi_inferior_exit
);
1347 gdb::observers::inferior_removed
.attach (mi_inferior_removed
);
1348 gdb::observers::record_changed
.attach (mi_record_changed
);
1349 gdb::observers::normal_stop
.attach (mi_on_normal_stop
);
1350 gdb::observers::target_resumed
.attach (mi_on_resume
);
1351 gdb::observers::solib_loaded
.attach (mi_solib_loaded
);
1352 gdb::observers::solib_unloaded
.attach (mi_solib_unloaded
);
1353 gdb::observers::about_to_proceed
.attach (mi_about_to_proceed
);
1354 gdb::observers::traceframe_changed
.attach (mi_traceframe_changed
);
1355 gdb::observers::tsv_created
.attach (mi_tsv_created
);
1356 gdb::observers::tsv_deleted
.attach (mi_tsv_deleted
);
1357 gdb::observers::tsv_modified
.attach (mi_tsv_modified
);
1358 gdb::observers::breakpoint_created
.attach (mi_breakpoint_created
);
1359 gdb::observers::breakpoint_deleted
.attach (mi_breakpoint_deleted
);
1360 gdb::observers::breakpoint_modified
.attach (mi_breakpoint_modified
);
1361 gdb::observers::command_param_changed
.attach (mi_command_param_changed
);
1362 gdb::observers::memory_changed
.attach (mi_memory_changed
);
1363 gdb::observers::sync_execution_done
.attach (mi_on_sync_execution_done
);
1364 gdb::observers::user_selected_context_changed
.attach
1365 (mi_user_selected_context_changed
);