1 /* MI Interpreter Definitions and Commands for GDB, the GNU debugger.
3 Copyright (C) 2002-2016 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 (ui_out_is_mi_like_p (interp_ui_out (interp
)))
111 return (struct mi_interp
*) interp_data (interp
);
116 mi_interpreter_init (struct interp
*interp
, int top_level
)
118 struct mi_interp
*mi
= XNEW (struct mi_interp
);
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
= mi_console_file_new (mi
->raw_stdout
, "~", '"');
130 mi
->err
= mi_console_file_new (mi
->raw_stdout
, "&", '"');
132 mi
->targ
= mi_console_file_new (mi
->raw_stdout
, "@", '"');
133 mi
->event_channel
= mi_console_file_new (mi
->raw_stdout
, "=", 0);
135 name
= interp_name (interp
);
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 mi_interpreter_resume (void *data
)
167 struct mi_interp
*mi
= (struct mi_interp
*) data
;
168 struct ui
*ui
= current_ui
;
170 /* As per hack note in mi_interpreter_init, swap in the output
172 gdb_setup_readline (0);
174 ui
->call_readline
= gdb_readline_no_editing_callback
;
175 ui
->input_handler
= mi_execute_command_input_handler
;
177 gdb_stdout
= mi
->out
;
178 /* Route error and log output through the MI. */
179 gdb_stderr
= mi
->err
;
180 gdb_stdlog
= mi
->log
;
181 /* Route target output through the MI. */
182 gdb_stdtarg
= mi
->targ
;
183 /* Route target error through the MI as well. */
184 gdb_stdtargerr
= mi
->targ
;
186 /* Replace all the hooks that we know about. There really needs to
187 be a better way of doing this... */
188 clear_interpreter_hooks ();
190 deprecated_show_load_progress
= mi_load_progress
;
196 mi_interpreter_suspend (void *data
)
198 gdb_disable_readline ();
202 static struct gdb_exception
203 mi_interpreter_exec (void *data
, const char *command
)
205 mi_execute_command_wrapper (command
);
206 return exception_none
;
210 mi_cmd_interpreter_exec (char *command
, char **argv
, int argc
)
212 struct interp
*interp_to_use
;
214 char *mi_error_message
= NULL
;
215 struct cleanup
*old_chain
;
218 error (_("-interpreter-exec: "
219 "Usage: -interpreter-exec interp command"));
221 interp_to_use
= interp_lookup (current_ui
, argv
[0]);
222 if (interp_to_use
== NULL
)
223 error (_("-interpreter-exec: could not find interpreter \"%s\""),
226 /* Note that unlike the CLI version of this command, we don't
227 actually set INTERP_TO_USE as the current interpreter, as we
228 still want gdb_stdout, etc. to point at MI streams. */
230 /* Insert the MI out hooks, making sure to also call the
231 interpreter's hooks if it has any. */
232 /* KRS: We shouldn't need this... Events should be installed and
233 they should just ALWAYS fire something out down the MI
235 mi_insert_notify_hooks ();
237 /* Now run the code. */
239 old_chain
= make_cleanup (null_cleanup
, 0);
240 for (i
= 1; i
< argc
; i
++)
242 struct gdb_exception e
= interp_exec (interp_to_use
, argv
[i
]);
246 mi_error_message
= xstrdup (e
.message
);
247 make_cleanup (xfree
, mi_error_message
);
252 mi_remove_notify_hooks ();
254 if (mi_error_message
!= NULL
)
255 error ("%s", mi_error_message
);
256 do_cleanups (old_chain
);
259 /* This inserts a number of hooks that are meant to produce
260 async-notify ("=") MI messages while running commands in another
261 interpreter using mi_interpreter_exec. The canonical use for this
262 is to allow access to the gdb CLI interpreter from within the MI,
263 while still producing MI style output when actions in the CLI
264 command change GDB's state. */
267 mi_insert_notify_hooks (void)
269 deprecated_query_hook
= mi_interp_query_hook
;
273 mi_remove_notify_hooks (void)
275 deprecated_query_hook
= NULL
;
279 mi_interp_query_hook (const char *ctlstr
, va_list ap
)
285 mi_execute_command_wrapper (const char *cmd
)
287 struct ui
*ui
= current_ui
;
289 mi_execute_command (cmd
, ui
->instream
== ui
->stdin_stream
);
292 /* Observer for the synchronous_command_done notification. */
295 mi_on_sync_execution_done (void)
297 struct ui
*ui
= current_ui
;
298 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
303 /* If MI is sync, then output the MI prompt now, indicating we're
304 ready for further input. */
306 display_mi_prompt (mi
);
309 /* mi_execute_command_wrapper wrapper suitable for INPUT_HANDLER. */
312 mi_execute_command_input_handler (char *cmd
)
314 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
315 struct ui
*ui
= current_ui
;
317 ui
->prompt_state
= PROMPT_NEEDED
;
319 mi_execute_command_wrapper (cmd
);
321 /* Print a prompt, indicating we're ready for further input, unless
322 we just started a synchronous command. In that case, we're about
323 to go back to the event loop and will output the prompt in the
324 'synchronous_command_done' observer when the target next
326 if (ui
->prompt_state
== PROMPT_NEEDED
)
327 display_mi_prompt (mi
);
331 mi_interpreter_pre_command_loop (struct interp
*self
)
333 struct mi_interp
*mi
= (struct mi_interp
*) interp_data (self
);
335 /* Turn off 8 bit strings in quoted output. Any character with the
336 high bit set is printed using C's octal format. */
337 sevenbit_strings
= 1;
339 /* Tell the world that we're alive. */
340 display_mi_prompt (mi
);
344 mi_new_thread (struct thread_info
*t
)
346 struct inferior
*inf
= find_inferior_ptid (t
->ptid
);
350 SWITCH_THRU_ALL_UIS ()
352 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
353 struct cleanup
*old_chain
;
358 old_chain
= make_cleanup_restore_target_terminal ();
359 target_terminal_ours_for_output ();
361 fprintf_unfiltered (mi
->event_channel
,
362 "thread-created,id=\"%d\",group-id=\"i%d\"",
363 t
->global_num
, inf
->num
);
364 gdb_flush (mi
->event_channel
);
366 do_cleanups (old_chain
);
371 mi_thread_exit (struct thread_info
*t
, int silent
)
376 SWITCH_THRU_ALL_UIS ()
378 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
379 struct cleanup
*old_chain
;
384 old_chain
= make_cleanup_restore_target_terminal ();
385 target_terminal_ours_for_output ();
386 fprintf_unfiltered (mi
->event_channel
,
387 "thread-exited,id=\"%d\",group-id=\"i%d\"",
388 t
->global_num
, t
->inf
->num
);
389 gdb_flush (mi
->event_channel
);
391 do_cleanups (old_chain
);
395 /* Emit notification on changing the state of record. */
398 mi_record_changed (struct inferior
*inferior
, int started
, const char *method
,
401 SWITCH_THRU_ALL_UIS ()
403 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
404 struct cleanup
*old_chain
;
409 old_chain
= make_cleanup_restore_target_terminal ();
410 target_terminal_ours_for_output ();
416 fprintf_unfiltered (mi
->event_channel
,
417 "record-started,thread-group=\"i%d\","
418 "method=\"%s\",format=\"%s\"",
419 inferior
->num
, method
, format
);
423 fprintf_unfiltered (mi
->event_channel
,
424 "record-started,thread-group=\"i%d\","
426 inferior
->num
, method
);
431 fprintf_unfiltered (mi
->event_channel
,
432 "record-stopped,thread-group=\"i%d\"",
436 gdb_flush (mi
->event_channel
);
438 do_cleanups (old_chain
);
443 mi_inferior_added (struct inferior
*inf
)
445 SWITCH_THRU_ALL_UIS ()
447 struct interp
*interp
;
448 struct mi_interp
*mi
;
449 struct cleanup
*old_chain
;
451 /* We'll be called once for the initial inferior, before the top
452 level interpreter is set. */
453 interp
= top_level_interpreter ();
457 mi
= as_mi_interp (interp
);
461 old_chain
= make_cleanup_restore_target_terminal ();
462 target_terminal_ours_for_output ();
464 fprintf_unfiltered (mi
->event_channel
,
465 "thread-group-added,id=\"i%d\"",
467 gdb_flush (mi
->event_channel
);
469 do_cleanups (old_chain
);
474 mi_inferior_appeared (struct inferior
*inf
)
476 SWITCH_THRU_ALL_UIS ()
478 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
479 struct cleanup
*old_chain
;
484 old_chain
= make_cleanup_restore_target_terminal ();
485 target_terminal_ours_for_output ();
487 fprintf_unfiltered (mi
->event_channel
,
488 "thread-group-started,id=\"i%d\",pid=\"%d\"",
490 gdb_flush (mi
->event_channel
);
491 do_cleanups (old_chain
);
496 mi_inferior_exit (struct inferior
*inf
)
498 SWITCH_THRU_ALL_UIS ()
500 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
501 struct cleanup
*old_chain
;
506 old_chain
= make_cleanup_restore_target_terminal ();
507 target_terminal_ours_for_output ();
509 if (inf
->has_exit_code
)
510 fprintf_unfiltered (mi
->event_channel
,
511 "thread-group-exited,id=\"i%d\",exit-code=\"%s\"",
512 inf
->num
, int_string (inf
->exit_code
, 8, 0, 0, 1));
514 fprintf_unfiltered (mi
->event_channel
,
515 "thread-group-exited,id=\"i%d\"", inf
->num
);
517 gdb_flush (mi
->event_channel
);
518 do_cleanups (old_chain
);
523 mi_inferior_removed (struct inferior
*inf
)
525 SWITCH_THRU_ALL_UIS ()
527 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
528 struct cleanup
*old_chain
;
533 old_chain
= make_cleanup_restore_target_terminal ();
534 target_terminal_ours_for_output ();
536 fprintf_unfiltered (mi
->event_channel
,
537 "thread-group-removed,id=\"i%d\"",
539 gdb_flush (mi
->event_channel
);
541 do_cleanups (old_chain
);
545 /* Return the MI interpreter, if it is active -- either because it's
546 the top-level interpreter or the interpreter executing the current
547 command. Returns NULL if the MI interpreter is not being used. */
549 static struct mi_interp
*
550 find_mi_interp (void)
552 struct mi_interp
*mi
;
554 mi
= as_mi_interp (top_level_interpreter ());
558 mi
= as_mi_interp (command_interp ());
565 /* Observers for several run control events that print why the
566 inferior has stopped to both the the MI event channel and to the MI
567 console. If the MI interpreter is not active, print nothing. */
569 /* Observer for the signal_received notification. */
572 mi_on_signal_received (enum gdb_signal siggnal
)
574 SWITCH_THRU_ALL_UIS ()
576 struct mi_interp
*mi
= find_mi_interp ();
581 print_signal_received_reason (mi
->mi_uiout
, siggnal
);
582 print_signal_received_reason (mi
->cli_uiout
, siggnal
);
586 /* Observer for the end_stepping_range notification. */
589 mi_on_end_stepping_range (void)
591 SWITCH_THRU_ALL_UIS ()
593 struct mi_interp
*mi
= find_mi_interp ();
598 print_end_stepping_range_reason (mi
->mi_uiout
);
599 print_end_stepping_range_reason (mi
->cli_uiout
);
603 /* Observer for the signal_exited notification. */
606 mi_on_signal_exited (enum gdb_signal siggnal
)
608 SWITCH_THRU_ALL_UIS ()
610 struct mi_interp
*mi
= find_mi_interp ();
615 print_signal_exited_reason (mi
->mi_uiout
, siggnal
);
616 print_signal_exited_reason (mi
->cli_uiout
, siggnal
);
620 /* Observer for the exited notification. */
623 mi_on_exited (int exitstatus
)
625 SWITCH_THRU_ALL_UIS ()
627 struct mi_interp
*mi
= find_mi_interp ();
632 print_exited_reason (mi
->mi_uiout
, exitstatus
);
633 print_exited_reason (mi
->cli_uiout
, exitstatus
);
637 /* Observer for the no_history notification. */
640 mi_on_no_history (void)
642 SWITCH_THRU_ALL_UIS ()
644 struct mi_interp
*mi
= find_mi_interp ();
649 print_no_history_reason (mi
->mi_uiout
);
650 print_no_history_reason (mi
->cli_uiout
);
655 mi_on_normal_stop_1 (struct bpstats
*bs
, int print_frame
)
657 /* Since this can be called when CLI command is executing,
658 using cli interpreter, be sure to use MI uiout for output,
659 not the current one. */
660 struct ui_out
*mi_uiout
= interp_ui_out (top_level_interpreter ());
661 struct mi_interp
*mi
= (struct mi_interp
*) top_level_interpreter_data ();
665 struct thread_info
*tp
;
667 struct interp
*console_interp
;
669 tp
= inferior_thread ();
671 if (tp
->thread_fsm
!= NULL
672 && thread_fsm_finished_p (tp
->thread_fsm
))
674 enum async_reply_reason reason
;
676 reason
= thread_fsm_async_reply_reason (tp
->thread_fsm
);
677 ui_out_field_string (mi_uiout
, "reason",
678 async_reason_lookup (reason
));
680 print_stop_event (mi_uiout
);
682 console_interp
= interp_lookup (current_ui
, INTERP_CONSOLE
);
683 if (should_print_stop_to_console (console_interp
, tp
))
684 print_stop_event (mi
->cli_uiout
);
686 ui_out_field_int (mi_uiout
, "thread-id", tp
->global_num
);
689 struct cleanup
*back_to
= make_cleanup_ui_out_list_begin_end
690 (mi_uiout
, "stopped-threads");
692 ui_out_field_int (mi_uiout
, NULL
, tp
->global_num
);
693 do_cleanups (back_to
);
696 ui_out_field_string (mi_uiout
, "stopped-threads", "all");
698 core
= target_core_of_thread (inferior_ptid
);
700 ui_out_field_int (mi_uiout
, "core", core
);
703 fputs_unfiltered ("*stopped", mi
->raw_stdout
);
704 mi_out_put (mi_uiout
, mi
->raw_stdout
);
705 mi_out_rewind (mi_uiout
);
706 mi_print_timing_maybe (mi
->raw_stdout
);
707 fputs_unfiltered ("\n", mi
->raw_stdout
);
708 gdb_flush (mi
->raw_stdout
);
712 mi_on_normal_stop (struct bpstats
*bs
, int print_frame
)
714 SWITCH_THRU_ALL_UIS ()
716 if (as_mi_interp (top_level_interpreter ()) == NULL
)
719 mi_on_normal_stop_1 (bs
, print_frame
);
724 mi_about_to_proceed (void)
726 /* Suppress output while calling an inferior function. */
728 if (!ptid_equal (inferior_ptid
, null_ptid
))
730 struct thread_info
*tp
= inferior_thread ();
732 if (tp
->control
.in_infcall
)
739 /* When the element is non-zero, no MI notifications will be emitted in
740 response to the corresponding observers. */
742 struct mi_suppress_notification mi_suppress_notification
=
750 /* Emit notification on changing a traceframe. */
753 mi_traceframe_changed (int tfnum
, int tpnum
)
755 if (mi_suppress_notification
.traceframe
)
758 SWITCH_THRU_ALL_UIS ()
760 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
761 struct cleanup
*old_chain
;
766 old_chain
= make_cleanup_restore_target_terminal ();
767 target_terminal_ours_for_output ();
770 fprintf_unfiltered (mi
->event_channel
, "traceframe-changed,"
771 "num=\"%d\",tracepoint=\"%d\"\n",
774 fprintf_unfiltered (mi
->event_channel
, "traceframe-changed,end");
776 gdb_flush (mi
->event_channel
);
778 do_cleanups (old_chain
);
782 /* Emit notification on creating a trace state variable. */
785 mi_tsv_created (const struct trace_state_variable
*tsv
)
787 SWITCH_THRU_ALL_UIS ()
789 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
790 struct cleanup
*old_chain
;
795 old_chain
= make_cleanup_restore_target_terminal ();
796 target_terminal_ours_for_output ();
798 fprintf_unfiltered (mi
->event_channel
, "tsv-created,"
799 "name=\"%s\",initial=\"%s\"\n",
800 tsv
->name
, plongest (tsv
->initial_value
));
802 gdb_flush (mi
->event_channel
);
804 do_cleanups (old_chain
);
808 /* Emit notification on deleting a trace state variable. */
811 mi_tsv_deleted (const struct trace_state_variable
*tsv
)
813 SWITCH_THRU_ALL_UIS ()
815 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
816 struct cleanup
*old_chain
;
821 old_chain
= make_cleanup_restore_target_terminal ();
822 target_terminal_ours_for_output ();
825 fprintf_unfiltered (mi
->event_channel
, "tsv-deleted,"
826 "name=\"%s\"\n", tsv
->name
);
828 fprintf_unfiltered (mi
->event_channel
, "tsv-deleted\n");
830 gdb_flush (mi
->event_channel
);
832 do_cleanups (old_chain
);
836 /* Emit notification on modifying a trace state variable. */
839 mi_tsv_modified (const struct trace_state_variable
*tsv
)
841 SWITCH_THRU_ALL_UIS ()
843 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
844 struct ui_out
*mi_uiout
;
845 struct cleanup
*old_chain
;
850 mi_uiout
= interp_ui_out (top_level_interpreter ());
852 old_chain
= make_cleanup_restore_target_terminal ();
853 target_terminal_ours_for_output ();
855 fprintf_unfiltered (mi
->event_channel
,
858 ui_out_redirect (mi_uiout
, mi
->event_channel
);
860 ui_out_field_string (mi_uiout
, "name", tsv
->name
);
861 ui_out_field_string (mi_uiout
, "initial",
862 plongest (tsv
->initial_value
));
863 if (tsv
->value_known
)
864 ui_out_field_string (mi_uiout
, "current", plongest (tsv
->value
));
866 ui_out_redirect (mi_uiout
, NULL
);
868 gdb_flush (mi
->event_channel
);
870 do_cleanups (old_chain
);
874 /* Emit notification about a created breakpoint. */
877 mi_breakpoint_created (struct breakpoint
*b
)
879 if (mi_suppress_notification
.breakpoint
)
885 SWITCH_THRU_ALL_UIS ()
887 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
888 struct ui_out
*mi_uiout
;
889 struct cleanup
*old_chain
;
894 mi_uiout
= interp_ui_out (top_level_interpreter ());
896 old_chain
= make_cleanup_restore_target_terminal ();
897 target_terminal_ours_for_output ();
899 fprintf_unfiltered (mi
->event_channel
,
900 "breakpoint-created");
901 /* We want the output from gdb_breakpoint_query to go to
902 mi->event_channel. One approach would be to just call
903 gdb_breakpoint_query, and then use mi_out_put to send the current
904 content of mi_outout into mi->event_channel. However, that will
905 break if anything is output to mi_uiout prior to calling the
906 breakpoint_created notifications. So, we use
908 ui_out_redirect (mi_uiout
, mi
->event_channel
);
911 gdb_breakpoint_query (mi_uiout
, b
->number
, NULL
);
913 CATCH (e
, RETURN_MASK_ERROR
)
918 ui_out_redirect (mi_uiout
, NULL
);
920 gdb_flush (mi
->event_channel
);
922 do_cleanups (old_chain
);
926 /* Emit notification about deleted breakpoint. */
929 mi_breakpoint_deleted (struct breakpoint
*b
)
931 if (mi_suppress_notification
.breakpoint
)
937 SWITCH_THRU_ALL_UIS ()
939 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
940 struct cleanup
*old_chain
;
945 old_chain
= make_cleanup_restore_target_terminal ();
946 target_terminal_ours_for_output ();
948 fprintf_unfiltered (mi
->event_channel
, "breakpoint-deleted,id=\"%d\"",
951 gdb_flush (mi
->event_channel
);
953 do_cleanups (old_chain
);
957 /* Emit notification about modified breakpoint. */
960 mi_breakpoint_modified (struct breakpoint
*b
)
962 if (mi_suppress_notification
.breakpoint
)
968 SWITCH_THRU_ALL_UIS ()
970 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
971 struct cleanup
*old_chain
;
976 old_chain
= make_cleanup_restore_target_terminal ();
977 target_terminal_ours_for_output ();
978 fprintf_unfiltered (mi
->event_channel
,
979 "breakpoint-modified");
980 /* We want the output from gdb_breakpoint_query to go to
981 mi->event_channel. One approach would be to just call
982 gdb_breakpoint_query, and then use mi_out_put to send the current
983 content of mi_outout into mi->event_channel. However, that will
984 break if anything is output to mi_uiout prior to calling the
985 breakpoint_created notifications. So, we use
987 ui_out_redirect (mi
->mi_uiout
, mi
->event_channel
);
990 gdb_breakpoint_query (mi
->mi_uiout
, b
->number
, NULL
);
992 CATCH (e
, RETURN_MASK_ERROR
)
997 ui_out_redirect (mi
->mi_uiout
, NULL
);
999 gdb_flush (mi
->event_channel
);
1001 do_cleanups (old_chain
);
1006 mi_output_running_pid (struct thread_info
*info
, void *arg
)
1008 ptid_t
*ptid
= (ptid_t
*) arg
;
1010 SWITCH_THRU_ALL_UIS ()
1012 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1017 if (ptid_get_pid (*ptid
) == ptid_get_pid (info
->ptid
))
1018 fprintf_unfiltered (mi
->raw_stdout
,
1019 "*running,thread-id=\"%d\"\n",
1027 mi_inferior_count (struct inferior
*inf
, void *arg
)
1031 int *count_p
= (int *) arg
;
1039 mi_on_resume_1 (struct mi_interp
*mi
, ptid_t ptid
)
1041 /* To cater for older frontends, emit ^running, but do it only once
1042 per each command. We do it here, since at this point we know
1043 that the target was successfully resumed, and in non-async mode,
1044 we won't return back to MI interpreter code until the target
1045 is done running, so delaying the output of "^running" until then
1046 will make it impossible for frontend to know what's going on.
1048 In future (MI3), we'll be outputting "^done" here. */
1049 if (!running_result_record_printed
&& mi_proceeded
)
1051 fprintf_unfiltered (mi
->raw_stdout
, "%s^running\n",
1052 current_token
? current_token
: "");
1055 if (ptid_get_pid (ptid
) == -1)
1056 fprintf_unfiltered (mi
->raw_stdout
, "*running,thread-id=\"all\"\n");
1057 else if (ptid_is_pid (ptid
))
1061 /* Backwards compatibility. If there's only one inferior,
1062 output "all", otherwise, output each resumed thread
1064 iterate_over_inferiors (mi_inferior_count
, &count
);
1067 fprintf_unfiltered (mi
->raw_stdout
, "*running,thread-id=\"all\"\n");
1069 iterate_over_threads (mi_output_running_pid
, &ptid
);
1073 struct thread_info
*ti
= find_thread_ptid (ptid
);
1076 fprintf_unfiltered (mi
->raw_stdout
, "*running,thread-id=\"%d\"\n",
1080 if (!running_result_record_printed
&& mi_proceeded
)
1082 running_result_record_printed
= 1;
1083 /* This is what gdb used to do historically -- printing prompt
1084 even if it cannot actually accept any input. This will be
1085 surely removed for MI3, and may be removed even earlier. */
1086 if (current_ui
->prompt_state
== PROMPT_BLOCKED
)
1087 fputs_unfiltered ("(gdb) \n", mi
->raw_stdout
);
1089 gdb_flush (mi
->raw_stdout
);
1093 mi_on_resume (ptid_t ptid
)
1095 struct thread_info
*tp
= NULL
;
1097 if (ptid_equal (ptid
, minus_one_ptid
) || ptid_is_pid (ptid
))
1098 tp
= inferior_thread ();
1100 tp
= find_thread_ptid (ptid
);
1102 /* Suppress output while calling an inferior function. */
1103 if (tp
->control
.in_infcall
)
1106 SWITCH_THRU_ALL_UIS ()
1108 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1109 struct cleanup
*old_chain
;
1114 old_chain
= make_cleanup_restore_target_terminal ();
1115 target_terminal_ours_for_output ();
1117 mi_on_resume_1 (mi
, ptid
);
1119 do_cleanups (old_chain
);
1124 mi_solib_loaded (struct so_list
*solib
)
1126 SWITCH_THRU_ALL_UIS ()
1128 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1129 struct ui_out
*uiout
;
1130 struct cleanup
*old_chain
;
1135 uiout
= interp_ui_out (top_level_interpreter ());
1137 old_chain
= make_cleanup_restore_target_terminal ();
1138 target_terminal_ours_for_output ();
1140 fprintf_unfiltered (mi
->event_channel
, "library-loaded");
1142 ui_out_redirect (uiout
, mi
->event_channel
);
1144 ui_out_field_string (uiout
, "id", solib
->so_original_name
);
1145 ui_out_field_string (uiout
, "target-name", solib
->so_original_name
);
1146 ui_out_field_string (uiout
, "host-name", solib
->so_name
);
1147 ui_out_field_int (uiout
, "symbols-loaded", solib
->symbols_loaded
);
1148 if (!gdbarch_has_global_solist (target_gdbarch ()))
1150 ui_out_field_fmt (uiout
, "thread-group", "i%d",
1151 current_inferior ()->num
);
1154 ui_out_redirect (uiout
, NULL
);
1156 gdb_flush (mi
->event_channel
);
1158 do_cleanups (old_chain
);
1163 mi_solib_unloaded (struct so_list
*solib
)
1165 SWITCH_THRU_ALL_UIS ()
1167 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1168 struct ui_out
*uiout
;
1169 struct cleanup
*old_chain
;
1174 uiout
= interp_ui_out (top_level_interpreter ());
1176 old_chain
= make_cleanup_restore_target_terminal ();
1177 target_terminal_ours_for_output ();
1179 fprintf_unfiltered (mi
->event_channel
, "library-unloaded");
1181 ui_out_redirect (uiout
, mi
->event_channel
);
1183 ui_out_field_string (uiout
, "id", solib
->so_original_name
);
1184 ui_out_field_string (uiout
, "target-name", solib
->so_original_name
);
1185 ui_out_field_string (uiout
, "host-name", solib
->so_name
);
1186 if (!gdbarch_has_global_solist (target_gdbarch ()))
1188 ui_out_field_fmt (uiout
, "thread-group", "i%d",
1189 current_inferior ()->num
);
1192 ui_out_redirect (uiout
, NULL
);
1194 gdb_flush (mi
->event_channel
);
1196 do_cleanups (old_chain
);
1200 /* Emit notification about the command parameter change. */
1203 mi_command_param_changed (const char *param
, const char *value
)
1205 if (mi_suppress_notification
.cmd_param_changed
)
1208 SWITCH_THRU_ALL_UIS ()
1210 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1211 struct ui_out
*mi_uiout
;
1212 struct cleanup
*old_chain
;
1217 mi_uiout
= interp_ui_out (top_level_interpreter ());
1219 old_chain
= make_cleanup_restore_target_terminal ();
1220 target_terminal_ours_for_output ();
1222 fprintf_unfiltered (mi
->event_channel
, "cmd-param-changed");
1224 ui_out_redirect (mi_uiout
, mi
->event_channel
);
1226 ui_out_field_string (mi_uiout
, "param", param
);
1227 ui_out_field_string (mi_uiout
, "value", value
);
1229 ui_out_redirect (mi_uiout
, NULL
);
1231 gdb_flush (mi
->event_channel
);
1233 do_cleanups (old_chain
);
1237 /* Emit notification about the target memory change. */
1240 mi_memory_changed (struct inferior
*inferior
, CORE_ADDR memaddr
,
1241 ssize_t len
, const bfd_byte
*myaddr
)
1243 if (mi_suppress_notification
.memory
)
1246 SWITCH_THRU_ALL_UIS ()
1248 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1249 struct ui_out
*mi_uiout
;
1250 struct obj_section
*sec
;
1251 struct cleanup
*old_chain
;
1256 mi_uiout
= interp_ui_out (top_level_interpreter ());
1258 old_chain
= make_cleanup_restore_target_terminal ();
1259 target_terminal_ours_for_output ();
1261 fprintf_unfiltered (mi
->event_channel
, "memory-changed");
1263 ui_out_redirect (mi_uiout
, mi
->event_channel
);
1265 ui_out_field_fmt (mi_uiout
, "thread-group", "i%d", inferior
->num
);
1266 ui_out_field_core_addr (mi_uiout
, "addr", target_gdbarch (), memaddr
);
1267 ui_out_field_fmt (mi_uiout
, "len", "%s", hex_string (len
));
1269 /* Append 'type=code' into notification if MEMADDR falls in the range of
1270 sections contain code. */
1271 sec
= find_pc_section (memaddr
);
1272 if (sec
!= NULL
&& sec
->objfile
!= NULL
)
1274 flagword flags
= bfd_get_section_flags (sec
->objfile
->obfd
,
1275 sec
->the_bfd_section
);
1277 if (flags
& SEC_CODE
)
1278 ui_out_field_string (mi_uiout
, "type", "code");
1281 ui_out_redirect (mi_uiout
, NULL
);
1283 gdb_flush (mi
->event_channel
);
1285 do_cleanups (old_chain
);
1289 /* Emit an event when the selection context (inferior, thread, frame)
1293 mi_user_selected_context_changed (user_selected_what selection
)
1295 struct thread_info
*tp
;
1297 /* Don't send an event if we're responding to an MI command. */
1298 if (mi_suppress_notification
.user_selected_context
)
1301 tp
= find_thread_ptid (inferior_ptid
);
1303 SWITCH_THRU_ALL_UIS ()
1305 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1306 struct ui_out
*mi_uiout
;
1307 struct cleanup
*old_chain
;
1312 mi_uiout
= interp_ui_out (top_level_interpreter ());
1314 ui_out_redirect (mi_uiout
, mi
->event_channel
);
1316 old_chain
= make_cleanup_ui_out_redirect_pop (mi_uiout
);
1318 make_cleanup_restore_target_terminal ();
1319 target_terminal_ours_for_output ();
1321 if (selection
& USER_SELECTED_INFERIOR
)
1322 print_selected_inferior (mi
->cli_uiout
);
1325 && (selection
& (USER_SELECTED_THREAD
| USER_SELECTED_FRAME
)))
1327 print_selected_thread_frame (mi
->cli_uiout
, selection
);
1329 fprintf_unfiltered (mi
->event_channel
,
1330 "thread-selected,id=\"%d\"",
1333 if (tp
->state
!= THREAD_RUNNING
)
1335 if (has_stack_frames ())
1336 print_stack_frame_to_uiout (mi_uiout
, get_selected_frame (NULL
),
1341 gdb_flush (mi
->event_channel
);
1342 do_cleanups (old_chain
);
1347 report_initial_inferior (struct inferior
*inf
, void *closure
)
1349 /* This function is called from mi_interpreter_init, and since
1350 mi_inferior_added assumes that inferior is fully initialized
1351 and top_level_interpreter_data is set, we cannot call
1353 struct mi_interp
*mi
= (struct mi_interp
*) closure
;
1354 struct cleanup
*old_chain
;
1356 old_chain
= make_cleanup_restore_target_terminal ();
1357 target_terminal_ours_for_output ();
1359 fprintf_unfiltered (mi
->event_channel
,
1360 "thread-group-added,id=\"i%d\"",
1362 gdb_flush (mi
->event_channel
);
1364 do_cleanups (old_chain
);
1368 static struct ui_out
*
1369 mi_ui_out (struct interp
*interp
)
1371 struct mi_interp
*mi
= (struct mi_interp
*) interp_data (interp
);
1373 return mi
->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_set_logging (struct interp
*interp
, int start_log
,
1381 struct ui_file
*out
, struct ui_file
*logfile
)
1383 struct mi_interp
*mi
= (struct mi_interp
*) interp_data (interp
);
1390 /* The tee created already is based on gdb_stdout, which for MI
1391 is a console and so we end up in an infinite loop of console
1392 writing to ui_file writing to console etc. So discard the
1393 existing tee (it hasn't been used yet, and MI won't ever use
1394 it), and create one based on raw_stdout instead. */
1397 ui_file_delete (out
);
1398 out
= tee_file_new (mi
->raw_stdout
, 0, logfile
, 0);
1401 mi
->saved_raw_stdout
= mi
->raw_stdout
;
1402 mi
->raw_stdout
= out
;
1406 mi
->raw_stdout
= mi
->saved_raw_stdout
;
1407 mi
->saved_raw_stdout
= NULL
;
1410 mi_console_set_raw (mi
->out
, mi
->raw_stdout
);
1411 mi_console_set_raw (mi
->err
, mi
->raw_stdout
);
1412 mi_console_set_raw (mi
->log
, mi
->raw_stdout
);
1413 mi_console_set_raw (mi
->targ
, mi
->raw_stdout
);
1414 mi_console_set_raw (mi
->event_channel
, mi
->raw_stdout
);
1419 /* The MI interpreter's vtable. */
1421 static const struct interp_procs mi_interp_procs
=
1423 mi_interpreter_init
, /* init_proc */
1424 mi_interpreter_resume
, /* resume_proc */
1425 mi_interpreter_suspend
, /* suspend_proc */
1426 mi_interpreter_exec
, /* exec_proc */
1427 mi_ui_out
, /* ui_out_proc */
1428 mi_set_logging
, /* set_logging_proc */
1429 mi_interpreter_pre_command_loop
/* pre_command_loop_proc */
1432 /* Factory for MI interpreters. */
1434 static struct interp
*
1435 mi_interp_factory (const char *name
)
1437 return interp_new (name
, &mi_interp_procs
, NULL
);
1440 extern initialize_file_ftype _initialize_mi_interp
; /* -Wmissing-prototypes */
1443 _initialize_mi_interp (void)
1445 /* The various interpreter levels. */
1446 interp_factory_register (INTERP_MI1
, mi_interp_factory
);
1447 interp_factory_register (INTERP_MI2
, mi_interp_factory
);
1448 interp_factory_register (INTERP_MI3
, mi_interp_factory
);
1449 interp_factory_register (INTERP_MI
, mi_interp_factory
);
1451 observer_attach_signal_received (mi_on_signal_received
);
1452 observer_attach_end_stepping_range (mi_on_end_stepping_range
);
1453 observer_attach_signal_exited (mi_on_signal_exited
);
1454 observer_attach_exited (mi_on_exited
);
1455 observer_attach_no_history (mi_on_no_history
);
1456 observer_attach_new_thread (mi_new_thread
);
1457 observer_attach_thread_exit (mi_thread_exit
);
1458 observer_attach_inferior_added (mi_inferior_added
);
1459 observer_attach_inferior_appeared (mi_inferior_appeared
);
1460 observer_attach_inferior_exit (mi_inferior_exit
);
1461 observer_attach_inferior_removed (mi_inferior_removed
);
1462 observer_attach_record_changed (mi_record_changed
);
1463 observer_attach_normal_stop (mi_on_normal_stop
);
1464 observer_attach_target_resumed (mi_on_resume
);
1465 observer_attach_solib_loaded (mi_solib_loaded
);
1466 observer_attach_solib_unloaded (mi_solib_unloaded
);
1467 observer_attach_about_to_proceed (mi_about_to_proceed
);
1468 observer_attach_traceframe_changed (mi_traceframe_changed
);
1469 observer_attach_tsv_created (mi_tsv_created
);
1470 observer_attach_tsv_deleted (mi_tsv_deleted
);
1471 observer_attach_tsv_modified (mi_tsv_modified
);
1472 observer_attach_breakpoint_created (mi_breakpoint_created
);
1473 observer_attach_breakpoint_deleted (mi_breakpoint_deleted
);
1474 observer_attach_breakpoint_modified (mi_breakpoint_modified
);
1475 observer_attach_command_param_changed (mi_command_param_changed
);
1476 observer_attach_memory_changed (mi_memory_changed
);
1477 observer_attach_sync_execution_done (mi_on_sync_execution_done
);
1478 observer_attach_user_selected_context_changed
1479 (mi_user_selected_context_changed
);