1 /* MI Interpreter Definitions and Commands for GDB, the GNU debugger.
3 Copyright (C) 2002-2017 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"
34 #include "gdbthread.h"
38 #include "tracepoint.h"
40 #include "thread-fsm.h"
41 #include "cli/cli-interp.h"
43 /* These are the interpreter setup, etc. functions for the MI
46 static void mi_execute_command_wrapper (const char *cmd
);
47 static void mi_execute_command_input_handler (char *cmd
);
49 /* These are hooks that we put in place while doing interpreter_exec
50 so we can report interesting things that happened "behind the MI's
51 back" in this command. */
53 static int mi_interp_query_hook (const char *ctlstr
, va_list ap
)
54 ATTRIBUTE_PRINTF (1, 0);
56 static void mi_insert_notify_hooks (void);
57 static void mi_remove_notify_hooks (void);
59 static void mi_on_signal_received (enum gdb_signal siggnal
);
60 static void mi_on_end_stepping_range (void);
61 static void mi_on_signal_exited (enum gdb_signal siggnal
);
62 static void mi_on_exited (int exitstatus
);
63 static void mi_on_normal_stop (struct bpstats
*bs
, int print_frame
);
64 static void mi_on_no_history (void);
66 static void mi_new_thread (struct thread_info
*t
);
67 static void mi_thread_exit (struct thread_info
*t
, int silent
);
68 static void mi_record_changed (struct inferior
*, int, const char *,
70 static void mi_inferior_added (struct inferior
*inf
);
71 static void mi_inferior_appeared (struct inferior
*inf
);
72 static void mi_inferior_exit (struct inferior
*inf
);
73 static void mi_inferior_removed (struct inferior
*inf
);
74 static void mi_on_resume (ptid_t ptid
);
75 static void mi_solib_loaded (struct so_list
*solib
);
76 static void mi_solib_unloaded (struct so_list
*solib
);
77 static void mi_about_to_proceed (void);
78 static void mi_traceframe_changed (int tfnum
, int tpnum
);
79 static void mi_tsv_created (const struct trace_state_variable
*tsv
);
80 static void mi_tsv_deleted (const struct trace_state_variable
*tsv
);
81 static void mi_tsv_modified (const struct trace_state_variable
*tsv
);
82 static void mi_breakpoint_created (struct breakpoint
*b
);
83 static void mi_breakpoint_deleted (struct breakpoint
*b
);
84 static void mi_breakpoint_modified (struct breakpoint
*b
);
85 static void mi_command_param_changed (const char *param
, const char *value
);
86 static void mi_memory_changed (struct inferior
*inf
, CORE_ADDR memaddr
,
87 ssize_t len
, const bfd_byte
*myaddr
);
88 static void mi_on_sync_execution_done (void);
90 static int report_initial_inferior (struct inferior
*inf
, void *closure
);
92 /* Display the MI prompt. */
95 display_mi_prompt (struct mi_interp
*mi
)
97 struct ui
*ui
= current_ui
;
99 fputs_unfiltered ("(gdb) \n", mi
->raw_stdout
);
100 gdb_flush (mi
->raw_stdout
);
101 ui
->prompt_state
= PROMPTED
;
104 /* Returns the INTERP's data cast as mi_interp if INTERP is an MI, and
105 returns NULL otherwise. */
107 static struct mi_interp
*
108 as_mi_interp (struct interp
*interp
)
110 if (interp_ui_out (interp
)->is_mi_like_p ())
111 return (struct mi_interp
*) interp
;
116 mi_interp::init (bool top_level
)
118 mi_interp
*mi
= this;
122 /* Store the current output channel, so that we can create a console
123 channel that encapsulates and prefixes all gdb_output-type bits
124 coming from the rest of the debugger. */
125 mi
->raw_stdout
= gdb_stdout
;
127 /* Create MI console channels, each with a different prefix so they
128 can be distinguished. */
129 mi
->out
= new mi_console_file (mi
->raw_stdout
, "~", '"');
130 mi
->err
= new mi_console_file (mi
->raw_stdout
, "&", '"');
132 mi
->targ
= new mi_console_file (mi
->raw_stdout
, "@", '"');
133 mi
->event_channel
= new mi_console_file (mi
->raw_stdout
, "=", 0);
135 name
= interp_name (this);
136 /* INTERP_MI selects the most recent released version. "mi2" was
137 released as part of GDB 6.0. */
138 if (strcmp (name
, INTERP_MI
) == 0)
140 else if (strcmp (name
, INTERP_MI1
) == 0)
142 else if (strcmp (name
, INTERP_MI2
) == 0)
144 else if (strcmp (name
, INTERP_MI3
) == 0)
147 gdb_assert_not_reached ("unhandled MI version");
149 mi
->mi_uiout
= mi_out_new (mi_version
);
150 mi
->cli_uiout
= cli_out_new (mi
->out
);
154 /* The initial inferior is created before this function is
155 called, so we need to report it explicitly. Use iteration in
156 case future version of GDB creates more than one inferior
158 iterate_over_inferiors (report_initial_inferior
, mi
);
165 struct mi_interp
*mi
= this;
166 struct ui
*ui
= current_ui
;
168 /* As per hack note in mi_interpreter_init, swap in the output
170 gdb_setup_readline (0);
172 ui
->call_readline
= gdb_readline_no_editing_callback
;
173 ui
->input_handler
= mi_execute_command_input_handler
;
175 gdb_stdout
= mi
->out
;
176 /* Route error and log output through the MI. */
177 gdb_stderr
= mi
->err
;
178 gdb_stdlog
= mi
->log
;
179 /* Route target output through the MI. */
180 gdb_stdtarg
= mi
->targ
;
181 /* Route target error through the MI as well. */
182 gdb_stdtargerr
= mi
->targ
;
184 /* Replace all the hooks that we know about. There really needs to
185 be a better way of doing this... */
186 clear_interpreter_hooks ();
188 deprecated_show_load_progress
= mi_load_progress
;
192 mi_interp::suspend ()
194 gdb_disable_readline ();
198 mi_interp::exec (const char *command
)
200 mi_execute_command_wrapper (command
);
201 return exception_none
;
205 mi_cmd_interpreter_exec (const char *command
, char **argv
, int argc
)
207 struct interp
*interp_to_use
;
211 error (_("-interpreter-exec: "
212 "Usage: -interpreter-exec interp command"));
214 interp_to_use
= interp_lookup (current_ui
, argv
[0]);
215 if (interp_to_use
== NULL
)
216 error (_("-interpreter-exec: could not find interpreter \"%s\""),
219 /* Note that unlike the CLI version of this command, we don't
220 actually set INTERP_TO_USE as the current interpreter, as we
221 still want gdb_stdout, etc. to point at MI streams. */
223 /* Insert the MI out hooks, making sure to also call the
224 interpreter's hooks if it has any. */
225 /* KRS: We shouldn't need this... Events should be installed and
226 they should just ALWAYS fire something out down the MI
228 mi_insert_notify_hooks ();
230 /* Now run the code. */
232 std::string mi_error_message
;
233 for (i
= 1; i
< argc
; i
++)
235 struct gdb_exception e
= interp_exec (interp_to_use
, argv
[i
]);
239 mi_error_message
= e
.message
;
244 mi_remove_notify_hooks ();
246 if (!mi_error_message
.empty ())
247 error ("%s", mi_error_message
.c_str ());
250 /* This inserts a number of hooks that are meant to produce
251 async-notify ("=") MI messages while running commands in another
252 interpreter using mi_interpreter_exec. The canonical use for this
253 is to allow access to the gdb CLI interpreter from within the MI,
254 while still producing MI style output when actions in the CLI
255 command change GDB's state. */
258 mi_insert_notify_hooks (void)
260 deprecated_query_hook
= mi_interp_query_hook
;
264 mi_remove_notify_hooks (void)
266 deprecated_query_hook
= NULL
;
270 mi_interp_query_hook (const char *ctlstr
, va_list ap
)
276 mi_execute_command_wrapper (const char *cmd
)
278 struct ui
*ui
= current_ui
;
280 mi_execute_command (cmd
, ui
->instream
== ui
->stdin_stream
);
283 /* Observer for the synchronous_command_done notification. */
286 mi_on_sync_execution_done (void)
288 struct ui
*ui
= current_ui
;
289 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
294 /* If MI is sync, then output the MI prompt now, indicating we're
295 ready for further input. */
297 display_mi_prompt (mi
);
300 /* mi_execute_command_wrapper wrapper suitable for INPUT_HANDLER. */
303 mi_execute_command_input_handler (char *cmd
)
305 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
306 struct ui
*ui
= current_ui
;
308 ui
->prompt_state
= PROMPT_NEEDED
;
310 mi_execute_command_wrapper (cmd
);
312 /* Print a prompt, indicating we're ready for further input, unless
313 we just started a synchronous command. In that case, we're about
314 to go back to the event loop and will output the prompt in the
315 'synchronous_command_done' observer when the target next
317 if (ui
->prompt_state
== PROMPT_NEEDED
)
318 display_mi_prompt (mi
);
322 mi_interp::pre_command_loop ()
324 struct mi_interp
*mi
= this;
326 /* Turn off 8 bit strings in quoted output. Any character with the
327 high bit set is printed using C's octal format. */
328 sevenbit_strings
= 1;
330 /* Tell the world that we're alive. */
331 display_mi_prompt (mi
);
335 mi_new_thread (struct thread_info
*t
)
337 struct inferior
*inf
= find_inferior_ptid (t
->ptid
);
341 SWITCH_THRU_ALL_UIS ()
343 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
344 struct cleanup
*old_chain
;
349 old_chain
= make_cleanup_restore_target_terminal ();
350 target_terminal_ours_for_output ();
352 fprintf_unfiltered (mi
->event_channel
,
353 "thread-created,id=\"%d\",group-id=\"i%d\"",
354 t
->global_num
, inf
->num
);
355 gdb_flush (mi
->event_channel
);
357 do_cleanups (old_chain
);
362 mi_thread_exit (struct thread_info
*t
, int silent
)
367 SWITCH_THRU_ALL_UIS ()
369 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
370 struct cleanup
*old_chain
;
375 old_chain
= make_cleanup_restore_target_terminal ();
376 target_terminal_ours_for_output ();
377 fprintf_unfiltered (mi
->event_channel
,
378 "thread-exited,id=\"%d\",group-id=\"i%d\"",
379 t
->global_num
, t
->inf
->num
);
380 gdb_flush (mi
->event_channel
);
382 do_cleanups (old_chain
);
386 /* Emit notification on changing the state of record. */
389 mi_record_changed (struct inferior
*inferior
, int started
, const char *method
,
392 SWITCH_THRU_ALL_UIS ()
394 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
395 struct cleanup
*old_chain
;
400 old_chain
= make_cleanup_restore_target_terminal ();
401 target_terminal_ours_for_output ();
407 fprintf_unfiltered (mi
->event_channel
,
408 "record-started,thread-group=\"i%d\","
409 "method=\"%s\",format=\"%s\"",
410 inferior
->num
, method
, format
);
414 fprintf_unfiltered (mi
->event_channel
,
415 "record-started,thread-group=\"i%d\","
417 inferior
->num
, method
);
422 fprintf_unfiltered (mi
->event_channel
,
423 "record-stopped,thread-group=\"i%d\"",
427 gdb_flush (mi
->event_channel
);
429 do_cleanups (old_chain
);
434 mi_inferior_added (struct inferior
*inf
)
436 SWITCH_THRU_ALL_UIS ()
438 struct interp
*interp
;
439 struct mi_interp
*mi
;
440 struct cleanup
*old_chain
;
442 /* We'll be called once for the initial inferior, before the top
443 level interpreter is set. */
444 interp
= top_level_interpreter ();
448 mi
= as_mi_interp (interp
);
452 old_chain
= make_cleanup_restore_target_terminal ();
453 target_terminal_ours_for_output ();
455 fprintf_unfiltered (mi
->event_channel
,
456 "thread-group-added,id=\"i%d\"",
458 gdb_flush (mi
->event_channel
);
460 do_cleanups (old_chain
);
465 mi_inferior_appeared (struct inferior
*inf
)
467 SWITCH_THRU_ALL_UIS ()
469 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
470 struct cleanup
*old_chain
;
475 old_chain
= make_cleanup_restore_target_terminal ();
476 target_terminal_ours_for_output ();
478 fprintf_unfiltered (mi
->event_channel
,
479 "thread-group-started,id=\"i%d\",pid=\"%d\"",
481 gdb_flush (mi
->event_channel
);
482 do_cleanups (old_chain
);
487 mi_inferior_exit (struct inferior
*inf
)
489 SWITCH_THRU_ALL_UIS ()
491 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
492 struct cleanup
*old_chain
;
497 old_chain
= make_cleanup_restore_target_terminal ();
498 target_terminal_ours_for_output ();
500 if (inf
->has_exit_code
)
501 fprintf_unfiltered (mi
->event_channel
,
502 "thread-group-exited,id=\"i%d\",exit-code=\"%s\"",
503 inf
->num
, int_string (inf
->exit_code
, 8, 0, 0, 1));
505 fprintf_unfiltered (mi
->event_channel
,
506 "thread-group-exited,id=\"i%d\"", inf
->num
);
508 gdb_flush (mi
->event_channel
);
509 do_cleanups (old_chain
);
514 mi_inferior_removed (struct inferior
*inf
)
516 SWITCH_THRU_ALL_UIS ()
518 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
519 struct cleanup
*old_chain
;
524 old_chain
= make_cleanup_restore_target_terminal ();
525 target_terminal_ours_for_output ();
527 fprintf_unfiltered (mi
->event_channel
,
528 "thread-group-removed,id=\"i%d\"",
530 gdb_flush (mi
->event_channel
);
532 do_cleanups (old_chain
);
536 /* Return the MI interpreter, if it is active -- either because it's
537 the top-level interpreter or the interpreter executing the current
538 command. Returns NULL if the MI interpreter is not being used. */
540 static struct mi_interp
*
541 find_mi_interp (void)
543 struct mi_interp
*mi
;
545 mi
= as_mi_interp (top_level_interpreter ());
549 mi
= as_mi_interp (command_interp ());
556 /* Observers for several run control events that print why the
557 inferior has stopped to both the the MI event channel and to the MI
558 console. If the MI interpreter is not active, print nothing. */
560 /* Observer for the signal_received notification. */
563 mi_on_signal_received (enum gdb_signal siggnal
)
565 SWITCH_THRU_ALL_UIS ()
567 struct mi_interp
*mi
= find_mi_interp ();
572 print_signal_received_reason (mi
->mi_uiout
, siggnal
);
573 print_signal_received_reason (mi
->cli_uiout
, siggnal
);
577 /* Observer for the end_stepping_range notification. */
580 mi_on_end_stepping_range (void)
582 SWITCH_THRU_ALL_UIS ()
584 struct mi_interp
*mi
= find_mi_interp ();
589 print_end_stepping_range_reason (mi
->mi_uiout
);
590 print_end_stepping_range_reason (mi
->cli_uiout
);
594 /* Observer for the signal_exited notification. */
597 mi_on_signal_exited (enum gdb_signal siggnal
)
599 SWITCH_THRU_ALL_UIS ()
601 struct mi_interp
*mi
= find_mi_interp ();
606 print_signal_exited_reason (mi
->mi_uiout
, siggnal
);
607 print_signal_exited_reason (mi
->cli_uiout
, siggnal
);
611 /* Observer for the exited notification. */
614 mi_on_exited (int exitstatus
)
616 SWITCH_THRU_ALL_UIS ()
618 struct mi_interp
*mi
= find_mi_interp ();
623 print_exited_reason (mi
->mi_uiout
, exitstatus
);
624 print_exited_reason (mi
->cli_uiout
, exitstatus
);
628 /* Observer for the no_history notification. */
631 mi_on_no_history (void)
633 SWITCH_THRU_ALL_UIS ()
635 struct mi_interp
*mi
= find_mi_interp ();
640 print_no_history_reason (mi
->mi_uiout
);
641 print_no_history_reason (mi
->cli_uiout
);
646 mi_on_normal_stop_1 (struct bpstats
*bs
, int print_frame
)
648 /* Since this can be called when CLI command is executing,
649 using cli interpreter, be sure to use MI uiout for output,
650 not the current one. */
651 struct ui_out
*mi_uiout
= interp_ui_out (top_level_interpreter ());
652 struct mi_interp
*mi
= (struct mi_interp
*) top_level_interpreter ();
656 struct thread_info
*tp
;
658 struct interp
*console_interp
;
660 tp
= inferior_thread ();
662 if (tp
->thread_fsm
!= NULL
663 && thread_fsm_finished_p (tp
->thread_fsm
))
665 enum async_reply_reason reason
;
667 reason
= thread_fsm_async_reply_reason (tp
->thread_fsm
);
668 mi_uiout
->field_string ("reason", async_reason_lookup (reason
));
670 print_stop_event (mi_uiout
);
672 console_interp
= interp_lookup (current_ui
, INTERP_CONSOLE
);
673 if (should_print_stop_to_console (console_interp
, tp
))
674 print_stop_event (mi
->cli_uiout
);
676 mi_uiout
->field_int ("thread-id", tp
->global_num
);
679 ui_out_emit_list
list_emitter (mi_uiout
, "stopped-threads");
681 mi_uiout
->field_int (NULL
, tp
->global_num
);
684 mi_uiout
->field_string ("stopped-threads", "all");
686 core
= target_core_of_thread (inferior_ptid
);
688 mi_uiout
->field_int ("core", core
);
691 fputs_unfiltered ("*stopped", mi
->raw_stdout
);
692 mi_out_put (mi_uiout
, mi
->raw_stdout
);
693 mi_out_rewind (mi_uiout
);
694 mi_print_timing_maybe (mi
->raw_stdout
);
695 fputs_unfiltered ("\n", mi
->raw_stdout
);
696 gdb_flush (mi
->raw_stdout
);
700 mi_on_normal_stop (struct bpstats
*bs
, int print_frame
)
702 SWITCH_THRU_ALL_UIS ()
704 if (as_mi_interp (top_level_interpreter ()) == NULL
)
707 mi_on_normal_stop_1 (bs
, print_frame
);
712 mi_about_to_proceed (void)
714 /* Suppress output while calling an inferior function. */
716 if (!ptid_equal (inferior_ptid
, null_ptid
))
718 struct thread_info
*tp
= inferior_thread ();
720 if (tp
->control
.in_infcall
)
727 /* When the element is non-zero, no MI notifications will be emitted in
728 response to the corresponding observers. */
730 struct mi_suppress_notification mi_suppress_notification
=
738 /* Emit notification on changing a traceframe. */
741 mi_traceframe_changed (int tfnum
, int tpnum
)
743 if (mi_suppress_notification
.traceframe
)
746 SWITCH_THRU_ALL_UIS ()
748 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
749 struct cleanup
*old_chain
;
754 old_chain
= make_cleanup_restore_target_terminal ();
755 target_terminal_ours_for_output ();
758 fprintf_unfiltered (mi
->event_channel
, "traceframe-changed,"
759 "num=\"%d\",tracepoint=\"%d\"\n",
762 fprintf_unfiltered (mi
->event_channel
, "traceframe-changed,end");
764 gdb_flush (mi
->event_channel
);
766 do_cleanups (old_chain
);
770 /* Emit notification on creating a trace state variable. */
773 mi_tsv_created (const struct trace_state_variable
*tsv
)
775 SWITCH_THRU_ALL_UIS ()
777 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
778 struct cleanup
*old_chain
;
783 old_chain
= make_cleanup_restore_target_terminal ();
784 target_terminal_ours_for_output ();
786 fprintf_unfiltered (mi
->event_channel
, "tsv-created,"
787 "name=\"%s\",initial=\"%s\"\n",
788 tsv
->name
, plongest (tsv
->initial_value
));
790 gdb_flush (mi
->event_channel
);
792 do_cleanups (old_chain
);
796 /* Emit notification on deleting a trace state variable. */
799 mi_tsv_deleted (const struct trace_state_variable
*tsv
)
801 SWITCH_THRU_ALL_UIS ()
803 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
804 struct cleanup
*old_chain
;
809 old_chain
= make_cleanup_restore_target_terminal ();
810 target_terminal_ours_for_output ();
813 fprintf_unfiltered (mi
->event_channel
, "tsv-deleted,"
814 "name=\"%s\"\n", tsv
->name
);
816 fprintf_unfiltered (mi
->event_channel
, "tsv-deleted\n");
818 gdb_flush (mi
->event_channel
);
820 do_cleanups (old_chain
);
824 /* Emit notification on modifying a trace state variable. */
827 mi_tsv_modified (const struct trace_state_variable
*tsv
)
829 SWITCH_THRU_ALL_UIS ()
831 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
832 struct ui_out
*mi_uiout
;
833 struct cleanup
*old_chain
;
838 mi_uiout
= interp_ui_out (top_level_interpreter ());
840 old_chain
= make_cleanup_restore_target_terminal ();
841 target_terminal_ours_for_output ();
843 fprintf_unfiltered (mi
->event_channel
,
846 mi_uiout
->redirect (mi
->event_channel
);
848 mi_uiout
->field_string ("name", tsv
->name
);
849 mi_uiout
->field_string ("initial",
850 plongest (tsv
->initial_value
));
851 if (tsv
->value_known
)
852 mi_uiout
->field_string ("current", plongest (tsv
->value
));
854 mi_uiout
->redirect (NULL
);
856 gdb_flush (mi
->event_channel
);
858 do_cleanups (old_chain
);
862 /* Emit notification about a created breakpoint. */
865 mi_breakpoint_created (struct breakpoint
*b
)
867 if (mi_suppress_notification
.breakpoint
)
873 SWITCH_THRU_ALL_UIS ()
875 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
876 struct ui_out
*mi_uiout
;
877 struct cleanup
*old_chain
;
882 mi_uiout
= interp_ui_out (top_level_interpreter ());
884 old_chain
= make_cleanup_restore_target_terminal ();
885 target_terminal_ours_for_output ();
887 fprintf_unfiltered (mi
->event_channel
,
888 "breakpoint-created");
889 /* We want the output from gdb_breakpoint_query to go to
890 mi->event_channel. One approach would be to just call
891 gdb_breakpoint_query, and then use mi_out_put to send the current
892 content of mi_uiout into mi->event_channel. However, that will
893 break if anything is output to mi_uiout prior to calling the
894 breakpoint_created notifications. So, we use
896 mi_uiout
->redirect (mi
->event_channel
);
899 gdb_breakpoint_query (mi_uiout
, b
->number
, NULL
);
901 CATCH (e
, RETURN_MASK_ERROR
)
906 mi_uiout
->redirect (NULL
);
908 gdb_flush (mi
->event_channel
);
910 do_cleanups (old_chain
);
914 /* Emit notification about deleted breakpoint. */
917 mi_breakpoint_deleted (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 ());
928 struct cleanup
*old_chain
;
933 old_chain
= make_cleanup_restore_target_terminal ();
934 target_terminal_ours_for_output ();
936 fprintf_unfiltered (mi
->event_channel
, "breakpoint-deleted,id=\"%d\"",
939 gdb_flush (mi
->event_channel
);
941 do_cleanups (old_chain
);
945 /* Emit notification about modified breakpoint. */
948 mi_breakpoint_modified (struct breakpoint
*b
)
950 if (mi_suppress_notification
.breakpoint
)
956 SWITCH_THRU_ALL_UIS ()
958 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
959 struct cleanup
*old_chain
;
964 old_chain
= make_cleanup_restore_target_terminal ();
965 target_terminal_ours_for_output ();
966 fprintf_unfiltered (mi
->event_channel
,
967 "breakpoint-modified");
968 /* We want the output from gdb_breakpoint_query to go to
969 mi->event_channel. One approach would be to just call
970 gdb_breakpoint_query, and then use mi_out_put to send the current
971 content of mi_uiout into mi->event_channel. However, that will
972 break if anything is output to mi_uiout prior to calling the
973 breakpoint_created notifications. So, we use
975 mi
->mi_uiout
->redirect (mi
->event_channel
);
978 gdb_breakpoint_query (mi
->mi_uiout
, b
->number
, NULL
);
980 CATCH (e
, RETURN_MASK_ERROR
)
985 mi
->mi_uiout
->redirect (NULL
);
987 gdb_flush (mi
->event_channel
);
989 do_cleanups (old_chain
);
994 mi_output_running_pid (struct thread_info
*info
, void *arg
)
996 ptid_t
*ptid
= (ptid_t
*) arg
;
998 SWITCH_THRU_ALL_UIS ()
1000 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1005 if (ptid_get_pid (*ptid
) == ptid_get_pid (info
->ptid
))
1006 fprintf_unfiltered (mi
->raw_stdout
,
1007 "*running,thread-id=\"%d\"\n",
1015 mi_inferior_count (struct inferior
*inf
, void *arg
)
1019 int *count_p
= (int *) arg
;
1027 mi_on_resume_1 (struct mi_interp
*mi
, ptid_t ptid
)
1029 /* To cater for older frontends, emit ^running, but do it only once
1030 per each command. We do it here, since at this point we know
1031 that the target was successfully resumed, and in non-async mode,
1032 we won't return back to MI interpreter code until the target
1033 is done running, so delaying the output of "^running" until then
1034 will make it impossible for frontend to know what's going on.
1036 In future (MI3), we'll be outputting "^done" here. */
1037 if (!running_result_record_printed
&& mi_proceeded
)
1039 fprintf_unfiltered (mi
->raw_stdout
, "%s^running\n",
1040 current_token
? current_token
: "");
1043 if (ptid_get_pid (ptid
) == -1)
1044 fprintf_unfiltered (mi
->raw_stdout
, "*running,thread-id=\"all\"\n");
1045 else if (ptid_is_pid (ptid
))
1049 /* Backwards compatibility. If there's only one inferior,
1050 output "all", otherwise, output each resumed thread
1052 iterate_over_inferiors (mi_inferior_count
, &count
);
1055 fprintf_unfiltered (mi
->raw_stdout
, "*running,thread-id=\"all\"\n");
1057 iterate_over_threads (mi_output_running_pid
, &ptid
);
1061 struct thread_info
*ti
= find_thread_ptid (ptid
);
1064 fprintf_unfiltered (mi
->raw_stdout
, "*running,thread-id=\"%d\"\n",
1068 if (!running_result_record_printed
&& mi_proceeded
)
1070 running_result_record_printed
= 1;
1071 /* This is what gdb used to do historically -- printing prompt
1072 even if it cannot actually accept any input. This will be
1073 surely removed for MI3, and may be removed even earlier. */
1074 if (current_ui
->prompt_state
== PROMPT_BLOCKED
)
1075 fputs_unfiltered ("(gdb) \n", mi
->raw_stdout
);
1077 gdb_flush (mi
->raw_stdout
);
1081 mi_on_resume (ptid_t ptid
)
1083 struct thread_info
*tp
= NULL
;
1085 if (ptid_equal (ptid
, minus_one_ptid
) || ptid_is_pid (ptid
))
1086 tp
= inferior_thread ();
1088 tp
= find_thread_ptid (ptid
);
1090 /* Suppress output while calling an inferior function. */
1091 if (tp
->control
.in_infcall
)
1094 SWITCH_THRU_ALL_UIS ()
1096 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1097 struct cleanup
*old_chain
;
1102 old_chain
= make_cleanup_restore_target_terminal ();
1103 target_terminal_ours_for_output ();
1105 mi_on_resume_1 (mi
, ptid
);
1107 do_cleanups (old_chain
);
1111 /* See mi-interp.h. */
1114 mi_output_solib_attribs (ui_out
*uiout
, struct so_list
*solib
)
1116 struct gdbarch
*gdbarch
= target_gdbarch ();
1118 uiout
->field_string ("id", solib
->so_original_name
);
1119 uiout
->field_string ("target-name", solib
->so_original_name
);
1120 uiout
->field_string ("host-name", solib
->so_name
);
1121 uiout
->field_int ("symbols-loaded", solib
->symbols_loaded
);
1122 if (!gdbarch_has_global_solist (target_gdbarch ()))
1123 uiout
->field_fmt ("thread-group", "i%d", current_inferior ()->num
);
1125 ui_out_emit_list
list_emitter (uiout
, "ranges");
1126 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1127 if (solib
->addr_high
!= 0)
1129 uiout
->field_core_addr ("from", gdbarch
, solib
->addr_low
);
1130 uiout
->field_core_addr ("to", gdbarch
, solib
->addr_high
);
1135 mi_solib_loaded (struct so_list
*solib
)
1137 SWITCH_THRU_ALL_UIS ()
1139 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1140 struct ui_out
*uiout
;
1141 struct cleanup
*old_chain
;
1146 uiout
= interp_ui_out (top_level_interpreter ());
1148 old_chain
= make_cleanup_restore_target_terminal ();
1149 target_terminal_ours_for_output ();
1151 fprintf_unfiltered (mi
->event_channel
, "library-loaded");
1153 uiout
->redirect (mi
->event_channel
);
1155 mi_output_solib_attribs (uiout
, solib
);
1157 uiout
->redirect (NULL
);
1159 gdb_flush (mi
->event_channel
);
1161 do_cleanups (old_chain
);
1166 mi_solib_unloaded (struct so_list
*solib
)
1168 SWITCH_THRU_ALL_UIS ()
1170 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1171 struct ui_out
*uiout
;
1172 struct cleanup
*old_chain
;
1177 uiout
= interp_ui_out (top_level_interpreter ());
1179 old_chain
= make_cleanup_restore_target_terminal ();
1180 target_terminal_ours_for_output ();
1182 fprintf_unfiltered (mi
->event_channel
, "library-unloaded");
1184 uiout
->redirect (mi
->event_channel
);
1186 uiout
->field_string ("id", solib
->so_original_name
);
1187 uiout
->field_string ("target-name", solib
->so_original_name
);
1188 uiout
->field_string ("host-name", solib
->so_name
);
1189 if (!gdbarch_has_global_solist (target_gdbarch ()))
1191 uiout
->field_fmt ("thread-group", "i%d", current_inferior ()->num
);
1194 uiout
->redirect (NULL
);
1196 gdb_flush (mi
->event_channel
);
1198 do_cleanups (old_chain
);
1202 /* Emit notification about the command parameter change. */
1205 mi_command_param_changed (const char *param
, const char *value
)
1207 if (mi_suppress_notification
.cmd_param_changed
)
1210 SWITCH_THRU_ALL_UIS ()
1212 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1213 struct ui_out
*mi_uiout
;
1214 struct cleanup
*old_chain
;
1219 mi_uiout
= interp_ui_out (top_level_interpreter ());
1221 old_chain
= make_cleanup_restore_target_terminal ();
1222 target_terminal_ours_for_output ();
1224 fprintf_unfiltered (mi
->event_channel
, "cmd-param-changed");
1226 mi_uiout
->redirect (mi
->event_channel
);
1228 mi_uiout
->field_string ("param", param
);
1229 mi_uiout
->field_string ("value", value
);
1231 mi_uiout
->redirect (NULL
);
1233 gdb_flush (mi
->event_channel
);
1235 do_cleanups (old_chain
);
1239 /* Emit notification about the target memory change. */
1242 mi_memory_changed (struct inferior
*inferior
, CORE_ADDR memaddr
,
1243 ssize_t len
, const bfd_byte
*myaddr
)
1245 if (mi_suppress_notification
.memory
)
1248 SWITCH_THRU_ALL_UIS ()
1250 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1251 struct ui_out
*mi_uiout
;
1252 struct obj_section
*sec
;
1253 struct cleanup
*old_chain
;
1258 mi_uiout
= interp_ui_out (top_level_interpreter ());
1260 old_chain
= make_cleanup_restore_target_terminal ();
1261 target_terminal_ours_for_output ();
1263 fprintf_unfiltered (mi
->event_channel
, "memory-changed");
1265 mi_uiout
->redirect (mi
->event_channel
);
1267 mi_uiout
->field_fmt ("thread-group", "i%d", inferior
->num
);
1268 mi_uiout
->field_core_addr ("addr", target_gdbarch (), memaddr
);
1269 mi_uiout
->field_fmt ("len", "%s", hex_string (len
));
1271 /* Append 'type=code' into notification if MEMADDR falls in the range of
1272 sections contain code. */
1273 sec
= find_pc_section (memaddr
);
1274 if (sec
!= NULL
&& sec
->objfile
!= NULL
)
1276 flagword flags
= bfd_get_section_flags (sec
->objfile
->obfd
,
1277 sec
->the_bfd_section
);
1279 if (flags
& SEC_CODE
)
1280 mi_uiout
->field_string ("type", "code");
1283 mi_uiout
->redirect (NULL
);
1285 gdb_flush (mi
->event_channel
);
1287 do_cleanups (old_chain
);
1291 /* Emit an event when the selection context (inferior, thread, frame)
1295 mi_user_selected_context_changed (user_selected_what selection
)
1297 struct thread_info
*tp
;
1299 /* Don't send an event if we're responding to an MI command. */
1300 if (mi_suppress_notification
.user_selected_context
)
1303 tp
= find_thread_ptid (inferior_ptid
);
1305 SWITCH_THRU_ALL_UIS ()
1307 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1308 struct ui_out
*mi_uiout
;
1309 struct cleanup
*old_chain
;
1314 mi_uiout
= interp_ui_out (top_level_interpreter ());
1316 mi_uiout
->redirect (mi
->event_channel
);
1318 old_chain
= make_cleanup_ui_out_redirect_pop (mi_uiout
);
1320 make_cleanup_restore_target_terminal ();
1321 target_terminal_ours_for_output ();
1323 if (selection
& USER_SELECTED_INFERIOR
)
1324 print_selected_inferior (mi
->cli_uiout
);
1327 && (selection
& (USER_SELECTED_THREAD
| USER_SELECTED_FRAME
)))
1329 print_selected_thread_frame (mi
->cli_uiout
, selection
);
1331 fprintf_unfiltered (mi
->event_channel
,
1332 "thread-selected,id=\"%d\"",
1335 if (tp
->state
!= THREAD_RUNNING
)
1337 if (has_stack_frames ())
1338 print_stack_frame_to_uiout (mi_uiout
, get_selected_frame (NULL
),
1343 gdb_flush (mi
->event_channel
);
1344 do_cleanups (old_chain
);
1349 report_initial_inferior (struct inferior
*inf
, void *closure
)
1351 /* This function is called from mi_interpreter_init, and since
1352 mi_inferior_added assumes that inferior is fully initialized
1353 and top_level_interpreter_data is set, we cannot call
1355 struct mi_interp
*mi
= (struct mi_interp
*) closure
;
1356 struct cleanup
*old_chain
;
1358 old_chain
= make_cleanup_restore_target_terminal ();
1359 target_terminal_ours_for_output ();
1361 fprintf_unfiltered (mi
->event_channel
,
1362 "thread-group-added,id=\"i%d\"",
1364 gdb_flush (mi
->event_channel
);
1366 do_cleanups (old_chain
);
1371 mi_interp::interp_ui_out ()
1373 return this->mi_uiout
;
1376 /* Do MI-specific logging actions; save raw_stdout, and change all
1377 the consoles to use the supplied ui-file(s). */
1380 mi_interp::set_logging (ui_file_up logfile
, bool logging_redirect
)
1382 struct mi_interp
*mi
= this;
1384 if (logfile
!= NULL
)
1386 mi
->saved_raw_stdout
= mi
->raw_stdout
;
1387 mi
->raw_stdout
= make_logging_output (mi
->raw_stdout
,
1388 std::move (logfile
),
1394 delete mi
->raw_stdout
;
1395 mi
->raw_stdout
= mi
->saved_raw_stdout
;
1396 mi
->saved_raw_stdout
= NULL
;
1399 mi
->out
->set_raw (mi
->raw_stdout
);
1400 mi
->err
->set_raw (mi
->raw_stdout
);
1401 mi
->log
->set_raw (mi
->raw_stdout
);
1402 mi
->targ
->set_raw (mi
->raw_stdout
);
1403 mi
->event_channel
->set_raw (mi
->raw_stdout
);
1406 /* Factory for MI interpreters. */
1408 static struct interp
*
1409 mi_interp_factory (const char *name
)
1411 return new mi_interp (name
);
1414 extern initialize_file_ftype _initialize_mi_interp
; /* -Wmissing-prototypes */
1417 _initialize_mi_interp (void)
1419 /* The various interpreter levels. */
1420 interp_factory_register (INTERP_MI1
, mi_interp_factory
);
1421 interp_factory_register (INTERP_MI2
, mi_interp_factory
);
1422 interp_factory_register (INTERP_MI3
, mi_interp_factory
);
1423 interp_factory_register (INTERP_MI
, mi_interp_factory
);
1425 observer_attach_signal_received (mi_on_signal_received
);
1426 observer_attach_end_stepping_range (mi_on_end_stepping_range
);
1427 observer_attach_signal_exited (mi_on_signal_exited
);
1428 observer_attach_exited (mi_on_exited
);
1429 observer_attach_no_history (mi_on_no_history
);
1430 observer_attach_new_thread (mi_new_thread
);
1431 observer_attach_thread_exit (mi_thread_exit
);
1432 observer_attach_inferior_added (mi_inferior_added
);
1433 observer_attach_inferior_appeared (mi_inferior_appeared
);
1434 observer_attach_inferior_exit (mi_inferior_exit
);
1435 observer_attach_inferior_removed (mi_inferior_removed
);
1436 observer_attach_record_changed (mi_record_changed
);
1437 observer_attach_normal_stop (mi_on_normal_stop
);
1438 observer_attach_target_resumed (mi_on_resume
);
1439 observer_attach_solib_loaded (mi_solib_loaded
);
1440 observer_attach_solib_unloaded (mi_solib_unloaded
);
1441 observer_attach_about_to_proceed (mi_about_to_proceed
);
1442 observer_attach_traceframe_changed (mi_traceframe_changed
);
1443 observer_attach_tsv_created (mi_tsv_created
);
1444 observer_attach_tsv_deleted (mi_tsv_deleted
);
1445 observer_attach_tsv_modified (mi_tsv_modified
);
1446 observer_attach_breakpoint_created (mi_breakpoint_created
);
1447 observer_attach_breakpoint_deleted (mi_breakpoint_deleted
);
1448 observer_attach_breakpoint_modified (mi_breakpoint_modified
);
1449 observer_attach_command_param_changed (mi_command_param_changed
);
1450 observer_attach_memory_changed (mi_memory_changed
);
1451 observer_attach_sync_execution_done (mi_on_sync_execution_done
);
1452 observer_attach_user_selected_context_changed
1453 (mi_user_selected_context_changed
);