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 (!ptid_equal (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",
955 mi_on_resume_1 (struct mi_interp
*mi
, ptid_t ptid
)
957 /* To cater for older frontends, emit ^running, but do it only once
958 per each command. We do it here, since at this point we know
959 that the target was successfully resumed, and in non-async mode,
960 we won't return back to MI interpreter code until the target
961 is done running, so delaying the output of "^running" until then
962 will make it impossible for frontend to know what's going on.
964 In future (MI3), we'll be outputting "^done" here. */
965 if (!running_result_record_printed
&& mi_proceeded
)
967 fprintf_unfiltered (mi
->raw_stdout
, "%s^running\n",
968 current_token
? current_token
: "");
971 if (ptid
.pid () == -1)
972 fprintf_unfiltered (mi
->raw_stdout
, "*running,thread-id=\"all\"\n");
973 else if (ptid
.is_pid ())
978 /* Backwards compatibility. If there's only one inferior,
979 output "all", otherwise, output each resumed thread
990 fprintf_unfiltered (mi
->raw_stdout
, "*running,thread-id=\"all\"\n");
994 inferior
*curinf
= current_inferior ();
996 ALL_NON_EXITED_THREADS (tp
)
997 if (tp
->inf
== curinf
)
998 mi_output_running (tp
);
1003 thread_info
*ti
= find_thread_ptid (ptid
);
1006 mi_output_running (ti
);
1009 if (!running_result_record_printed
&& mi_proceeded
)
1011 running_result_record_printed
= 1;
1012 /* This is what gdb used to do historically -- printing prompt
1013 even if it cannot actually accept any input. This will be
1014 surely removed for MI3, and may be removed even earlier. */
1015 if (current_ui
->prompt_state
== PROMPT_BLOCKED
)
1016 fputs_unfiltered ("(gdb) \n", mi
->raw_stdout
);
1018 gdb_flush (mi
->raw_stdout
);
1022 mi_on_resume (ptid_t ptid
)
1024 struct thread_info
*tp
= NULL
;
1026 if (ptid_equal (ptid
, minus_one_ptid
) || ptid
.is_pid ())
1027 tp
= inferior_thread ();
1029 tp
= find_thread_ptid (ptid
);
1031 /* Suppress output while calling an inferior function. */
1032 if (tp
->control
.in_infcall
)
1035 SWITCH_THRU_ALL_UIS ()
1037 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1042 target_terminal::scoped_restore_terminal_state term_state
;
1043 target_terminal::ours_for_output ();
1045 mi_on_resume_1 (mi
, ptid
);
1049 /* See mi-interp.h. */
1052 mi_output_solib_attribs (ui_out
*uiout
, struct so_list
*solib
)
1054 struct gdbarch
*gdbarch
= target_gdbarch ();
1056 uiout
->field_string ("id", solib
->so_original_name
);
1057 uiout
->field_string ("target-name", solib
->so_original_name
);
1058 uiout
->field_string ("host-name", solib
->so_name
);
1059 uiout
->field_int ("symbols-loaded", solib
->symbols_loaded
);
1060 if (!gdbarch_has_global_solist (target_gdbarch ()))
1061 uiout
->field_fmt ("thread-group", "i%d", current_inferior ()->num
);
1063 ui_out_emit_list
list_emitter (uiout
, "ranges");
1064 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1065 if (solib
->addr_high
!= 0)
1067 uiout
->field_core_addr ("from", gdbarch
, solib
->addr_low
);
1068 uiout
->field_core_addr ("to", gdbarch
, solib
->addr_high
);
1073 mi_solib_loaded (struct so_list
*solib
)
1075 SWITCH_THRU_ALL_UIS ()
1077 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1078 struct ui_out
*uiout
;
1083 uiout
= top_level_interpreter ()->interp_ui_out ();
1085 target_terminal::scoped_restore_terminal_state term_state
;
1086 target_terminal::ours_for_output ();
1088 fprintf_unfiltered (mi
->event_channel
, "library-loaded");
1090 uiout
->redirect (mi
->event_channel
);
1092 mi_output_solib_attribs (uiout
, solib
);
1094 uiout
->redirect (NULL
);
1096 gdb_flush (mi
->event_channel
);
1101 mi_solib_unloaded (struct so_list
*solib
)
1103 SWITCH_THRU_ALL_UIS ()
1105 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1106 struct ui_out
*uiout
;
1111 uiout
= top_level_interpreter ()->interp_ui_out ();
1113 target_terminal::scoped_restore_terminal_state term_state
;
1114 target_terminal::ours_for_output ();
1116 fprintf_unfiltered (mi
->event_channel
, "library-unloaded");
1118 uiout
->redirect (mi
->event_channel
);
1120 uiout
->field_string ("id", solib
->so_original_name
);
1121 uiout
->field_string ("target-name", solib
->so_original_name
);
1122 uiout
->field_string ("host-name", solib
->so_name
);
1123 if (!gdbarch_has_global_solist (target_gdbarch ()))
1125 uiout
->field_fmt ("thread-group", "i%d", current_inferior ()->num
);
1128 uiout
->redirect (NULL
);
1130 gdb_flush (mi
->event_channel
);
1134 /* Emit notification about the command parameter change. */
1137 mi_command_param_changed (const char *param
, const char *value
)
1139 if (mi_suppress_notification
.cmd_param_changed
)
1142 SWITCH_THRU_ALL_UIS ()
1144 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1145 struct ui_out
*mi_uiout
;
1150 mi_uiout
= top_level_interpreter ()->interp_ui_out ();
1152 target_terminal::scoped_restore_terminal_state term_state
;
1153 target_terminal::ours_for_output ();
1155 fprintf_unfiltered (mi
->event_channel
, "cmd-param-changed");
1157 mi_uiout
->redirect (mi
->event_channel
);
1159 mi_uiout
->field_string ("param", param
);
1160 mi_uiout
->field_string ("value", value
);
1162 mi_uiout
->redirect (NULL
);
1164 gdb_flush (mi
->event_channel
);
1168 /* Emit notification about the target memory change. */
1171 mi_memory_changed (struct inferior
*inferior
, CORE_ADDR memaddr
,
1172 ssize_t len
, const bfd_byte
*myaddr
)
1174 if (mi_suppress_notification
.memory
)
1177 SWITCH_THRU_ALL_UIS ()
1179 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1180 struct ui_out
*mi_uiout
;
1181 struct obj_section
*sec
;
1186 mi_uiout
= top_level_interpreter ()->interp_ui_out ();
1188 target_terminal::scoped_restore_terminal_state term_state
;
1189 target_terminal::ours_for_output ();
1191 fprintf_unfiltered (mi
->event_channel
, "memory-changed");
1193 mi_uiout
->redirect (mi
->event_channel
);
1195 mi_uiout
->field_fmt ("thread-group", "i%d", inferior
->num
);
1196 mi_uiout
->field_core_addr ("addr", target_gdbarch (), memaddr
);
1197 mi_uiout
->field_fmt ("len", "%s", hex_string (len
));
1199 /* Append 'type=code' into notification if MEMADDR falls in the range of
1200 sections contain code. */
1201 sec
= find_pc_section (memaddr
);
1202 if (sec
!= NULL
&& sec
->objfile
!= NULL
)
1204 flagword flags
= bfd_get_section_flags (sec
->objfile
->obfd
,
1205 sec
->the_bfd_section
);
1207 if (flags
& SEC_CODE
)
1208 mi_uiout
->field_string ("type", "code");
1211 mi_uiout
->redirect (NULL
);
1213 gdb_flush (mi
->event_channel
);
1217 /* Emit an event when the selection context (inferior, thread, frame)
1221 mi_user_selected_context_changed (user_selected_what selection
)
1223 struct thread_info
*tp
;
1225 /* Don't send an event if we're responding to an MI command. */
1226 if (mi_suppress_notification
.user_selected_context
)
1229 if (inferior_ptid
!= null_ptid
)
1230 tp
= inferior_thread ();
1234 SWITCH_THRU_ALL_UIS ()
1236 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1237 struct ui_out
*mi_uiout
;
1242 mi_uiout
= top_level_interpreter ()->interp_ui_out ();
1244 mi_uiout
->redirect (mi
->event_channel
);
1245 ui_out_redirect_pop
redirect_popper (mi_uiout
);
1247 target_terminal::scoped_restore_terminal_state term_state
;
1248 target_terminal::ours_for_output ();
1250 if (selection
& USER_SELECTED_INFERIOR
)
1251 print_selected_inferior (mi
->cli_uiout
);
1254 && (selection
& (USER_SELECTED_THREAD
| USER_SELECTED_FRAME
)))
1256 print_selected_thread_frame (mi
->cli_uiout
, selection
);
1258 fprintf_unfiltered (mi
->event_channel
,
1259 "thread-selected,id=\"%d\"",
1262 if (tp
->state
!= THREAD_RUNNING
)
1264 if (has_stack_frames ())
1265 print_stack_frame_to_uiout (mi_uiout
, get_selected_frame (NULL
),
1270 gdb_flush (mi
->event_channel
);
1275 report_initial_inferior (struct inferior
*inf
, void *closure
)
1277 /* This function is called from mi_interpreter_init, and since
1278 mi_inferior_added assumes that inferior is fully initialized
1279 and top_level_interpreter_data is set, we cannot call
1281 struct mi_interp
*mi
= (struct mi_interp
*) closure
;
1283 target_terminal::scoped_restore_terminal_state term_state
;
1284 target_terminal::ours_for_output ();
1286 fprintf_unfiltered (mi
->event_channel
,
1287 "thread-group-added,id=\"i%d\"",
1289 gdb_flush (mi
->event_channel
);
1295 mi_interp::interp_ui_out ()
1297 return this->mi_uiout
;
1300 /* Do MI-specific logging actions; save raw_stdout, and change all
1301 the consoles to use the supplied ui-file(s). */
1304 mi_interp::set_logging (ui_file_up logfile
, bool logging_redirect
)
1306 struct mi_interp
*mi
= this;
1308 if (logfile
!= NULL
)
1310 mi
->saved_raw_stdout
= mi
->raw_stdout
;
1311 mi
->raw_stdout
= make_logging_output (mi
->raw_stdout
,
1312 std::move (logfile
),
1318 delete mi
->raw_stdout
;
1319 mi
->raw_stdout
= mi
->saved_raw_stdout
;
1320 mi
->saved_raw_stdout
= NULL
;
1323 mi
->out
->set_raw (mi
->raw_stdout
);
1324 mi
->err
->set_raw (mi
->raw_stdout
);
1325 mi
->log
->set_raw (mi
->raw_stdout
);
1326 mi
->targ
->set_raw (mi
->raw_stdout
);
1327 mi
->event_channel
->set_raw (mi
->raw_stdout
);
1330 /* Factory for MI interpreters. */
1332 static struct interp
*
1333 mi_interp_factory (const char *name
)
1335 return new mi_interp (name
);
1339 _initialize_mi_interp (void)
1341 /* The various interpreter levels. */
1342 interp_factory_register (INTERP_MI1
, mi_interp_factory
);
1343 interp_factory_register (INTERP_MI2
, mi_interp_factory
);
1344 interp_factory_register (INTERP_MI3
, mi_interp_factory
);
1345 interp_factory_register (INTERP_MI
, mi_interp_factory
);
1347 gdb::observers::signal_received
.attach (mi_on_signal_received
);
1348 gdb::observers::end_stepping_range
.attach (mi_on_end_stepping_range
);
1349 gdb::observers::signal_exited
.attach (mi_on_signal_exited
);
1350 gdb::observers::exited
.attach (mi_on_exited
);
1351 gdb::observers::no_history
.attach (mi_on_no_history
);
1352 gdb::observers::new_thread
.attach (mi_new_thread
);
1353 gdb::observers::thread_exit
.attach (mi_thread_exit
);
1354 gdb::observers::inferior_added
.attach (mi_inferior_added
);
1355 gdb::observers::inferior_appeared
.attach (mi_inferior_appeared
);
1356 gdb::observers::inferior_exit
.attach (mi_inferior_exit
);
1357 gdb::observers::inferior_removed
.attach (mi_inferior_removed
);
1358 gdb::observers::record_changed
.attach (mi_record_changed
);
1359 gdb::observers::normal_stop
.attach (mi_on_normal_stop
);
1360 gdb::observers::target_resumed
.attach (mi_on_resume
);
1361 gdb::observers::solib_loaded
.attach (mi_solib_loaded
);
1362 gdb::observers::solib_unloaded
.attach (mi_solib_unloaded
);
1363 gdb::observers::about_to_proceed
.attach (mi_about_to_proceed
);
1364 gdb::observers::traceframe_changed
.attach (mi_traceframe_changed
);
1365 gdb::observers::tsv_created
.attach (mi_tsv_created
);
1366 gdb::observers::tsv_deleted
.attach (mi_tsv_deleted
);
1367 gdb::observers::tsv_modified
.attach (mi_tsv_modified
);
1368 gdb::observers::breakpoint_created
.attach (mi_breakpoint_created
);
1369 gdb::observers::breakpoint_deleted
.attach (mi_breakpoint_deleted
);
1370 gdb::observers::breakpoint_modified
.attach (mi_breakpoint_modified
);
1371 gdb::observers::command_param_changed
.attach (mi_command_param_changed
);
1372 gdb::observers::memory_changed
.attach (mi_memory_changed
);
1373 gdb::observers::sync_execution_done
.attach (mi_on_sync_execution_done
);
1374 gdb::observers::user_selected_context_changed
.attach
1375 (mi_user_selected_context_changed
);