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
);
347 struct switch_thru_all_uis state
;
351 SWITCH_THRU_ALL_UIS (state
)
353 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
354 struct cleanup
*old_chain
;
359 old_chain
= make_cleanup_restore_target_terminal ();
360 target_terminal_ours_for_output ();
362 fprintf_unfiltered (mi
->event_channel
,
363 "thread-created,id=\"%d\",group-id=\"i%d\"",
364 t
->global_num
, inf
->num
);
365 gdb_flush (mi
->event_channel
);
367 do_cleanups (old_chain
);
372 mi_thread_exit (struct thread_info
*t
, int silent
)
374 struct switch_thru_all_uis state
;
379 SWITCH_THRU_ALL_UIS (state
)
381 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
382 struct cleanup
*old_chain
;
387 old_chain
= make_cleanup_restore_target_terminal ();
388 target_terminal_ours_for_output ();
389 fprintf_unfiltered (mi
->event_channel
,
390 "thread-exited,id=\"%d\",group-id=\"i%d\"",
391 t
->global_num
, t
->inf
->num
);
392 gdb_flush (mi
->event_channel
);
394 do_cleanups (old_chain
);
398 /* Emit notification on changing the state of record. */
401 mi_record_changed (struct inferior
*inferior
, int started
, const char *method
,
404 struct switch_thru_all_uis state
;
406 SWITCH_THRU_ALL_UIS (state
)
408 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
409 struct cleanup
*old_chain
;
414 old_chain
= make_cleanup_restore_target_terminal ();
415 target_terminal_ours_for_output ();
421 fprintf_unfiltered (mi
->event_channel
,
422 "record-started,thread-group=\"i%d\","
423 "method=\"%s\",format=\"%s\"",
424 inferior
->num
, method
, format
);
428 fprintf_unfiltered (mi
->event_channel
,
429 "record-started,thread-group=\"i%d\","
431 inferior
->num
, method
);
436 fprintf_unfiltered (mi
->event_channel
,
437 "record-stopped,thread-group=\"i%d\"",
441 gdb_flush (mi
->event_channel
);
443 do_cleanups (old_chain
);
448 mi_inferior_added (struct inferior
*inf
)
450 struct switch_thru_all_uis state
;
452 SWITCH_THRU_ALL_UIS (state
)
454 struct interp
*interp
;
455 struct mi_interp
*mi
;
456 struct cleanup
*old_chain
;
458 /* We'll be called once for the initial inferior, before the top
459 level interpreter is set. */
460 interp
= top_level_interpreter ();
464 mi
= as_mi_interp (interp
);
468 old_chain
= make_cleanup_restore_target_terminal ();
469 target_terminal_ours_for_output ();
471 fprintf_unfiltered (mi
->event_channel
,
472 "thread-group-added,id=\"i%d\"",
474 gdb_flush (mi
->event_channel
);
476 do_cleanups (old_chain
);
481 mi_inferior_appeared (struct inferior
*inf
)
483 struct switch_thru_all_uis state
;
485 SWITCH_THRU_ALL_UIS (state
)
487 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
488 struct cleanup
*old_chain
;
493 old_chain
= make_cleanup_restore_target_terminal ();
494 target_terminal_ours_for_output ();
496 fprintf_unfiltered (mi
->event_channel
,
497 "thread-group-started,id=\"i%d\",pid=\"%d\"",
499 gdb_flush (mi
->event_channel
);
500 do_cleanups (old_chain
);
505 mi_inferior_exit (struct inferior
*inf
)
507 struct switch_thru_all_uis state
;
509 SWITCH_THRU_ALL_UIS (state
)
511 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
512 struct cleanup
*old_chain
;
517 old_chain
= make_cleanup_restore_target_terminal ();
518 target_terminal_ours_for_output ();
520 if (inf
->has_exit_code
)
521 fprintf_unfiltered (mi
->event_channel
,
522 "thread-group-exited,id=\"i%d\",exit-code=\"%s\"",
523 inf
->num
, int_string (inf
->exit_code
, 8, 0, 0, 1));
525 fprintf_unfiltered (mi
->event_channel
,
526 "thread-group-exited,id=\"i%d\"", inf
->num
);
528 gdb_flush (mi
->event_channel
);
529 do_cleanups (old_chain
);
534 mi_inferior_removed (struct inferior
*inf
)
536 struct switch_thru_all_uis state
;
538 SWITCH_THRU_ALL_UIS (state
)
540 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
541 struct cleanup
*old_chain
;
546 old_chain
= make_cleanup_restore_target_terminal ();
547 target_terminal_ours_for_output ();
549 fprintf_unfiltered (mi
->event_channel
,
550 "thread-group-removed,id=\"i%d\"",
552 gdb_flush (mi
->event_channel
);
554 do_cleanups (old_chain
);
558 /* Return the MI interpreter, if it is active -- either because it's
559 the top-level interpreter or the interpreter executing the current
560 command. Returns NULL if the MI interpreter is not being used. */
562 static struct mi_interp
*
563 find_mi_interp (void)
565 struct mi_interp
*mi
;
567 mi
= as_mi_interp (top_level_interpreter ());
571 mi
= as_mi_interp (command_interp ());
578 /* Observers for several run control events that print why the
579 inferior has stopped to both the the MI event channel and to the MI
580 console. If the MI interpreter is not active, print nothing. */
582 /* Observer for the signal_received notification. */
585 mi_on_signal_received (enum gdb_signal siggnal
)
587 struct switch_thru_all_uis state
;
589 SWITCH_THRU_ALL_UIS (state
)
591 struct mi_interp
*mi
= find_mi_interp ();
596 print_signal_received_reason (mi
->mi_uiout
, siggnal
);
597 print_signal_received_reason (mi
->cli_uiout
, siggnal
);
601 /* Observer for the end_stepping_range notification. */
604 mi_on_end_stepping_range (void)
606 struct switch_thru_all_uis state
;
608 SWITCH_THRU_ALL_UIS (state
)
610 struct mi_interp
*mi
= find_mi_interp ();
615 print_end_stepping_range_reason (mi
->mi_uiout
);
616 print_end_stepping_range_reason (mi
->cli_uiout
);
620 /* Observer for the signal_exited notification. */
623 mi_on_signal_exited (enum gdb_signal siggnal
)
625 struct switch_thru_all_uis state
;
627 SWITCH_THRU_ALL_UIS (state
)
629 struct mi_interp
*mi
= find_mi_interp ();
634 print_signal_exited_reason (mi
->mi_uiout
, siggnal
);
635 print_signal_exited_reason (mi
->cli_uiout
, siggnal
);
639 /* Observer for the exited notification. */
642 mi_on_exited (int exitstatus
)
644 struct switch_thru_all_uis state
;
646 SWITCH_THRU_ALL_UIS (state
)
648 struct mi_interp
*mi
= find_mi_interp ();
653 print_exited_reason (mi
->mi_uiout
, exitstatus
);
654 print_exited_reason (mi
->cli_uiout
, exitstatus
);
658 /* Observer for the no_history notification. */
661 mi_on_no_history (void)
663 struct switch_thru_all_uis state
;
665 SWITCH_THRU_ALL_UIS (state
)
667 struct mi_interp
*mi
= find_mi_interp ();
672 print_no_history_reason (mi
->mi_uiout
);
673 print_no_history_reason (mi
->cli_uiout
);
678 mi_on_normal_stop_1 (struct bpstats
*bs
, int print_frame
)
680 /* Since this can be called when CLI command is executing,
681 using cli interpreter, be sure to use MI uiout for output,
682 not the current one. */
683 struct ui_out
*mi_uiout
= interp_ui_out (top_level_interpreter ());
684 struct mi_interp
*mi
= (struct mi_interp
*) top_level_interpreter_data ();
688 struct thread_info
*tp
;
690 struct interp
*console_interp
;
692 tp
= inferior_thread ();
694 if (tp
->thread_fsm
!= NULL
695 && thread_fsm_finished_p (tp
->thread_fsm
))
697 enum async_reply_reason reason
;
699 reason
= thread_fsm_async_reply_reason (tp
->thread_fsm
);
700 ui_out_field_string (mi_uiout
, "reason",
701 async_reason_lookup (reason
));
703 print_stop_event (mi_uiout
);
705 console_interp
= interp_lookup (current_ui
, INTERP_CONSOLE
);
706 if (should_print_stop_to_console (console_interp
, tp
))
707 print_stop_event (mi
->cli_uiout
);
709 ui_out_field_int (mi_uiout
, "thread-id", tp
->global_num
);
712 struct cleanup
*back_to
= make_cleanup_ui_out_list_begin_end
713 (mi_uiout
, "stopped-threads");
715 ui_out_field_int (mi_uiout
, NULL
, tp
->global_num
);
716 do_cleanups (back_to
);
719 ui_out_field_string (mi_uiout
, "stopped-threads", "all");
721 core
= target_core_of_thread (inferior_ptid
);
723 ui_out_field_int (mi_uiout
, "core", core
);
726 fputs_unfiltered ("*stopped", mi
->raw_stdout
);
727 mi_out_put (mi_uiout
, mi
->raw_stdout
);
728 mi_out_rewind (mi_uiout
);
729 mi_print_timing_maybe (mi
->raw_stdout
);
730 fputs_unfiltered ("\n", mi
->raw_stdout
);
731 gdb_flush (mi
->raw_stdout
);
735 mi_on_normal_stop (struct bpstats
*bs
, int print_frame
)
737 struct switch_thru_all_uis state
;
739 SWITCH_THRU_ALL_UIS (state
)
741 if (as_mi_interp (top_level_interpreter ()) == NULL
)
744 mi_on_normal_stop_1 (bs
, print_frame
);
749 mi_about_to_proceed (void)
751 /* Suppress output while calling an inferior function. */
753 if (!ptid_equal (inferior_ptid
, null_ptid
))
755 struct thread_info
*tp
= inferior_thread ();
757 if (tp
->control
.in_infcall
)
764 /* When the element is non-zero, no MI notifications will be emitted in
765 response to the corresponding observers. */
767 struct mi_suppress_notification mi_suppress_notification
=
774 /* Emit notification on changing a traceframe. */
777 mi_traceframe_changed (int tfnum
, int tpnum
)
779 struct switch_thru_all_uis state
;
781 if (mi_suppress_notification
.traceframe
)
784 SWITCH_THRU_ALL_UIS (state
)
786 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
787 struct cleanup
*old_chain
;
792 old_chain
= make_cleanup_restore_target_terminal ();
793 target_terminal_ours_for_output ();
796 fprintf_unfiltered (mi
->event_channel
, "traceframe-changed,"
797 "num=\"%d\",tracepoint=\"%d\"\n",
800 fprintf_unfiltered (mi
->event_channel
, "traceframe-changed,end");
802 gdb_flush (mi
->event_channel
);
804 do_cleanups (old_chain
);
808 /* Emit notification on creating a trace state variable. */
811 mi_tsv_created (const struct trace_state_variable
*tsv
)
813 struct switch_thru_all_uis state
;
815 SWITCH_THRU_ALL_UIS (state
)
817 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
818 struct cleanup
*old_chain
;
823 old_chain
= make_cleanup_restore_target_terminal ();
824 target_terminal_ours_for_output ();
826 fprintf_unfiltered (mi
->event_channel
, "tsv-created,"
827 "name=\"%s\",initial=\"%s\"\n",
828 tsv
->name
, plongest (tsv
->initial_value
));
830 gdb_flush (mi
->event_channel
);
832 do_cleanups (old_chain
);
836 /* Emit notification on deleting a trace state variable. */
839 mi_tsv_deleted (const struct trace_state_variable
*tsv
)
841 struct switch_thru_all_uis state
;
843 SWITCH_THRU_ALL_UIS (state
)
845 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
846 struct cleanup
*old_chain
;
851 old_chain
= make_cleanup_restore_target_terminal ();
852 target_terminal_ours_for_output ();
855 fprintf_unfiltered (mi
->event_channel
, "tsv-deleted,"
856 "name=\"%s\"\n", tsv
->name
);
858 fprintf_unfiltered (mi
->event_channel
, "tsv-deleted\n");
860 gdb_flush (mi
->event_channel
);
862 do_cleanups (old_chain
);
866 /* Emit notification on modifying a trace state variable. */
869 mi_tsv_modified (const struct trace_state_variable
*tsv
)
871 struct switch_thru_all_uis state
;
873 SWITCH_THRU_ALL_UIS (state
)
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
,
890 ui_out_redirect (mi_uiout
, mi
->event_channel
);
892 ui_out_field_string (mi_uiout
, "name", tsv
->name
);
893 ui_out_field_string (mi_uiout
, "initial",
894 plongest (tsv
->initial_value
));
895 if (tsv
->value_known
)
896 ui_out_field_string (mi_uiout
, "current", plongest (tsv
->value
));
898 ui_out_redirect (mi_uiout
, NULL
);
900 gdb_flush (mi
->event_channel
);
902 do_cleanups (old_chain
);
906 /* Emit notification about a created breakpoint. */
909 mi_breakpoint_created (struct breakpoint
*b
)
911 struct switch_thru_all_uis state
;
913 if (mi_suppress_notification
.breakpoint
)
919 SWITCH_THRU_ALL_UIS (state
)
921 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
922 struct ui_out
*mi_uiout
;
923 struct cleanup
*old_chain
;
928 mi_uiout
= interp_ui_out (top_level_interpreter ());
930 old_chain
= make_cleanup_restore_target_terminal ();
931 target_terminal_ours_for_output ();
933 fprintf_unfiltered (mi
->event_channel
,
934 "breakpoint-created");
935 /* We want the output from gdb_breakpoint_query to go to
936 mi->event_channel. One approach would be to just call
937 gdb_breakpoint_query, and then use mi_out_put to send the current
938 content of mi_outout into mi->event_channel. However, that will
939 break if anything is output to mi_uiout prior to calling the
940 breakpoint_created notifications. So, we use
942 ui_out_redirect (mi_uiout
, mi
->event_channel
);
945 gdb_breakpoint_query (mi_uiout
, b
->number
, NULL
);
947 CATCH (e
, RETURN_MASK_ERROR
)
952 ui_out_redirect (mi_uiout
, NULL
);
954 gdb_flush (mi
->event_channel
);
956 do_cleanups (old_chain
);
960 /* Emit notification about deleted breakpoint. */
963 mi_breakpoint_deleted (struct breakpoint
*b
)
965 struct switch_thru_all_uis state
;
967 if (mi_suppress_notification
.breakpoint
)
973 SWITCH_THRU_ALL_UIS (state
)
975 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
976 struct cleanup
*old_chain
;
981 old_chain
= make_cleanup_restore_target_terminal ();
982 target_terminal_ours_for_output ();
984 fprintf_unfiltered (mi
->event_channel
, "breakpoint-deleted,id=\"%d\"",
987 gdb_flush (mi
->event_channel
);
989 do_cleanups (old_chain
);
993 /* Emit notification about modified breakpoint. */
996 mi_breakpoint_modified (struct breakpoint
*b
)
998 struct switch_thru_all_uis state
;
1000 if (mi_suppress_notification
.breakpoint
)
1006 SWITCH_THRU_ALL_UIS (state
)
1008 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1009 struct cleanup
*old_chain
;
1014 old_chain
= make_cleanup_restore_target_terminal ();
1015 target_terminal_ours_for_output ();
1016 fprintf_unfiltered (mi
->event_channel
,
1017 "breakpoint-modified");
1018 /* We want the output from gdb_breakpoint_query to go to
1019 mi->event_channel. One approach would be to just call
1020 gdb_breakpoint_query, and then use mi_out_put to send the current
1021 content of mi_outout into mi->event_channel. However, that will
1022 break if anything is output to mi_uiout prior to calling the
1023 breakpoint_created notifications. So, we use
1025 ui_out_redirect (mi
->mi_uiout
, mi
->event_channel
);
1028 gdb_breakpoint_query (mi
->mi_uiout
, b
->number
, NULL
);
1030 CATCH (e
, RETURN_MASK_ERROR
)
1035 ui_out_redirect (mi
->mi_uiout
, NULL
);
1037 gdb_flush (mi
->event_channel
);
1039 do_cleanups (old_chain
);
1044 mi_output_running_pid (struct thread_info
*info
, void *arg
)
1046 ptid_t
*ptid
= (ptid_t
*) arg
;
1047 struct switch_thru_all_uis state
;
1049 SWITCH_THRU_ALL_UIS (state
)
1051 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1056 if (ptid_get_pid (*ptid
) == ptid_get_pid (info
->ptid
))
1057 fprintf_unfiltered (mi
->raw_stdout
,
1058 "*running,thread-id=\"%d\"\n",
1066 mi_inferior_count (struct inferior
*inf
, void *arg
)
1070 int *count_p
= (int *) arg
;
1078 mi_on_resume_1 (struct mi_interp
*mi
, ptid_t ptid
)
1080 /* To cater for older frontends, emit ^running, but do it only once
1081 per each command. We do it here, since at this point we know
1082 that the target was successfully resumed, and in non-async mode,
1083 we won't return back to MI interpreter code until the target
1084 is done running, so delaying the output of "^running" until then
1085 will make it impossible for frontend to know what's going on.
1087 In future (MI3), we'll be outputting "^done" here. */
1088 if (!running_result_record_printed
&& mi_proceeded
)
1090 fprintf_unfiltered (mi
->raw_stdout
, "%s^running\n",
1091 current_token
? current_token
: "");
1094 if (ptid_get_pid (ptid
) == -1)
1095 fprintf_unfiltered (mi
->raw_stdout
, "*running,thread-id=\"all\"\n");
1096 else if (ptid_is_pid (ptid
))
1100 /* Backwards compatibility. If there's only one inferior,
1101 output "all", otherwise, output each resumed thread
1103 iterate_over_inferiors (mi_inferior_count
, &count
);
1106 fprintf_unfiltered (mi
->raw_stdout
, "*running,thread-id=\"all\"\n");
1108 iterate_over_threads (mi_output_running_pid
, &ptid
);
1112 struct thread_info
*ti
= find_thread_ptid (ptid
);
1115 fprintf_unfiltered (mi
->raw_stdout
, "*running,thread-id=\"%d\"\n",
1119 if (!running_result_record_printed
&& mi_proceeded
)
1121 running_result_record_printed
= 1;
1122 /* This is what gdb used to do historically -- printing prompt
1123 even if it cannot actually accept any input. This will be
1124 surely removed for MI3, and may be removed even earlier. */
1125 if (current_ui
->prompt_state
== PROMPT_BLOCKED
)
1126 fputs_unfiltered ("(gdb) \n", mi
->raw_stdout
);
1128 gdb_flush (mi
->raw_stdout
);
1132 mi_on_resume (ptid_t ptid
)
1134 struct thread_info
*tp
= NULL
;
1135 struct switch_thru_all_uis state
;
1137 if (ptid_equal (ptid
, minus_one_ptid
) || ptid_is_pid (ptid
))
1138 tp
= inferior_thread ();
1140 tp
= find_thread_ptid (ptid
);
1142 /* Suppress output while calling an inferior function. */
1143 if (tp
->control
.in_infcall
)
1146 SWITCH_THRU_ALL_UIS (state
)
1148 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1149 struct cleanup
*old_chain
;
1154 old_chain
= make_cleanup_restore_target_terminal ();
1155 target_terminal_ours_for_output ();
1157 mi_on_resume_1 (mi
, ptid
);
1159 do_cleanups (old_chain
);
1164 mi_solib_loaded (struct so_list
*solib
)
1166 struct switch_thru_all_uis state
;
1168 SWITCH_THRU_ALL_UIS (state
)
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-loaded");
1184 ui_out_redirect (uiout
, mi
->event_channel
);
1186 ui_out_field_string (uiout
, "id", solib
->so_original_name
);
1187 ui_out_field_string (uiout
, "target-name", solib
->so_original_name
);
1188 ui_out_field_string (uiout
, "host-name", solib
->so_name
);
1189 ui_out_field_int (uiout
, "symbols-loaded", solib
->symbols_loaded
);
1190 if (!gdbarch_has_global_solist (target_gdbarch ()))
1192 ui_out_field_fmt (uiout
, "thread-group", "i%d",
1193 current_inferior ()->num
);
1196 ui_out_redirect (uiout
, NULL
);
1198 gdb_flush (mi
->event_channel
);
1200 do_cleanups (old_chain
);
1205 mi_solib_unloaded (struct so_list
*solib
)
1207 struct switch_thru_all_uis state
;
1209 SWITCH_THRU_ALL_UIS (state
)
1211 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1212 struct ui_out
*uiout
;
1213 struct cleanup
*old_chain
;
1218 uiout
= interp_ui_out (top_level_interpreter ());
1220 old_chain
= make_cleanup_restore_target_terminal ();
1221 target_terminal_ours_for_output ();
1223 fprintf_unfiltered (mi
->event_channel
, "library-unloaded");
1225 ui_out_redirect (uiout
, mi
->event_channel
);
1227 ui_out_field_string (uiout
, "id", solib
->so_original_name
);
1228 ui_out_field_string (uiout
, "target-name", solib
->so_original_name
);
1229 ui_out_field_string (uiout
, "host-name", solib
->so_name
);
1230 if (!gdbarch_has_global_solist (target_gdbarch ()))
1232 ui_out_field_fmt (uiout
, "thread-group", "i%d",
1233 current_inferior ()->num
);
1236 ui_out_redirect (uiout
, NULL
);
1238 gdb_flush (mi
->event_channel
);
1240 do_cleanups (old_chain
);
1244 /* Emit notification about the command parameter change. */
1247 mi_command_param_changed (const char *param
, const char *value
)
1249 struct switch_thru_all_uis state
;
1251 if (mi_suppress_notification
.cmd_param_changed
)
1254 SWITCH_THRU_ALL_UIS (state
)
1256 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1257 struct ui_out
*mi_uiout
;
1258 struct cleanup
*old_chain
;
1263 mi_uiout
= interp_ui_out (top_level_interpreter ());
1265 old_chain
= make_cleanup_restore_target_terminal ();
1266 target_terminal_ours_for_output ();
1268 fprintf_unfiltered (mi
->event_channel
, "cmd-param-changed");
1270 ui_out_redirect (mi_uiout
, mi
->event_channel
);
1272 ui_out_field_string (mi_uiout
, "param", param
);
1273 ui_out_field_string (mi_uiout
, "value", value
);
1275 ui_out_redirect (mi_uiout
, NULL
);
1277 gdb_flush (mi
->event_channel
);
1279 do_cleanups (old_chain
);
1283 /* Emit notification about the target memory change. */
1286 mi_memory_changed (struct inferior
*inferior
, CORE_ADDR memaddr
,
1287 ssize_t len
, const bfd_byte
*myaddr
)
1289 struct switch_thru_all_uis state
;
1291 if (mi_suppress_notification
.memory
)
1294 SWITCH_THRU_ALL_UIS (state
)
1296 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1297 struct ui_out
*mi_uiout
;
1298 struct obj_section
*sec
;
1299 struct cleanup
*old_chain
;
1304 mi_uiout
= interp_ui_out (top_level_interpreter ());
1306 old_chain
= make_cleanup_restore_target_terminal ();
1307 target_terminal_ours_for_output ();
1309 fprintf_unfiltered (mi
->event_channel
, "memory-changed");
1311 ui_out_redirect (mi_uiout
, mi
->event_channel
);
1313 ui_out_field_fmt (mi_uiout
, "thread-group", "i%d", inferior
->num
);
1314 ui_out_field_core_addr (mi_uiout
, "addr", target_gdbarch (), memaddr
);
1315 ui_out_field_fmt (mi_uiout
, "len", "%s", hex_string (len
));
1317 /* Append 'type=code' into notification if MEMADDR falls in the range of
1318 sections contain code. */
1319 sec
= find_pc_section (memaddr
);
1320 if (sec
!= NULL
&& sec
->objfile
!= NULL
)
1322 flagword flags
= bfd_get_section_flags (sec
->objfile
->obfd
,
1323 sec
->the_bfd_section
);
1325 if (flags
& SEC_CODE
)
1326 ui_out_field_string (mi_uiout
, "type", "code");
1329 ui_out_redirect (mi_uiout
, NULL
);
1331 gdb_flush (mi
->event_channel
);
1333 do_cleanups (old_chain
);
1338 report_initial_inferior (struct inferior
*inf
, void *closure
)
1340 /* This function is called from mi_interpreter_init, and since
1341 mi_inferior_added assumes that inferior is fully initialized
1342 and top_level_interpreter_data is set, we cannot call
1344 struct mi_interp
*mi
= (struct mi_interp
*) closure
;
1345 struct cleanup
*old_chain
;
1347 old_chain
= make_cleanup_restore_target_terminal ();
1348 target_terminal_ours_for_output ();
1350 fprintf_unfiltered (mi
->event_channel
,
1351 "thread-group-added,id=\"i%d\"",
1353 gdb_flush (mi
->event_channel
);
1355 do_cleanups (old_chain
);
1359 static struct ui_out
*
1360 mi_ui_out (struct interp
*interp
)
1362 struct mi_interp
*mi
= (struct mi_interp
*) interp_data (interp
);
1364 return mi
->mi_uiout
;
1367 /* Do MI-specific logging actions; save raw_stdout, and change all
1368 the consoles to use the supplied ui-file(s). */
1371 mi_set_logging (struct interp
*interp
, int start_log
,
1372 struct ui_file
*out
, struct ui_file
*logfile
)
1374 struct mi_interp
*mi
= (struct mi_interp
*) interp_data (interp
);
1381 /* The tee created already is based on gdb_stdout, which for MI
1382 is a console and so we end up in an infinite loop of console
1383 writing to ui_file writing to console etc. So discard the
1384 existing tee (it hasn't been used yet, and MI won't ever use
1385 it), and create one based on raw_stdout instead. */
1388 ui_file_delete (out
);
1389 out
= tee_file_new (mi
->raw_stdout
, 0, logfile
, 0);
1392 mi
->saved_raw_stdout
= mi
->raw_stdout
;
1393 mi
->raw_stdout
= out
;
1397 mi
->raw_stdout
= mi
->saved_raw_stdout
;
1398 mi
->saved_raw_stdout
= NULL
;
1401 mi_console_set_raw (mi
->out
, mi
->raw_stdout
);
1402 mi_console_set_raw (mi
->err
, mi
->raw_stdout
);
1403 mi_console_set_raw (mi
->log
, mi
->raw_stdout
);
1404 mi_console_set_raw (mi
->targ
, mi
->raw_stdout
);
1405 mi_console_set_raw (mi
->event_channel
, mi
->raw_stdout
);
1410 /* The MI interpreter's vtable. */
1412 static const struct interp_procs mi_interp_procs
=
1414 mi_interpreter_init
, /* init_proc */
1415 mi_interpreter_resume
, /* resume_proc */
1416 mi_interpreter_suspend
, /* suspend_proc */
1417 mi_interpreter_exec
, /* exec_proc */
1418 mi_ui_out
, /* ui_out_proc */
1419 mi_set_logging
, /* set_logging_proc */
1420 mi_interpreter_pre_command_loop
/* pre_command_loop_proc */
1423 /* Factory for MI interpreters. */
1425 static struct interp
*
1426 mi_interp_factory (const char *name
)
1428 return interp_new (name
, &mi_interp_procs
, NULL
);
1431 extern initialize_file_ftype _initialize_mi_interp
; /* -Wmissing-prototypes */
1434 _initialize_mi_interp (void)
1436 /* The various interpreter levels. */
1437 interp_factory_register (INTERP_MI1
, mi_interp_factory
);
1438 interp_factory_register (INTERP_MI2
, mi_interp_factory
);
1439 interp_factory_register (INTERP_MI3
, mi_interp_factory
);
1440 interp_factory_register (INTERP_MI
, mi_interp_factory
);
1442 observer_attach_signal_received (mi_on_signal_received
);
1443 observer_attach_end_stepping_range (mi_on_end_stepping_range
);
1444 observer_attach_signal_exited (mi_on_signal_exited
);
1445 observer_attach_exited (mi_on_exited
);
1446 observer_attach_no_history (mi_on_no_history
);
1447 observer_attach_new_thread (mi_new_thread
);
1448 observer_attach_thread_exit (mi_thread_exit
);
1449 observer_attach_inferior_added (mi_inferior_added
);
1450 observer_attach_inferior_appeared (mi_inferior_appeared
);
1451 observer_attach_inferior_exit (mi_inferior_exit
);
1452 observer_attach_inferior_removed (mi_inferior_removed
);
1453 observer_attach_record_changed (mi_record_changed
);
1454 observer_attach_normal_stop (mi_on_normal_stop
);
1455 observer_attach_target_resumed (mi_on_resume
);
1456 observer_attach_solib_loaded (mi_solib_loaded
);
1457 observer_attach_solib_unloaded (mi_solib_unloaded
);
1458 observer_attach_about_to_proceed (mi_about_to_proceed
);
1459 observer_attach_traceframe_changed (mi_traceframe_changed
);
1460 observer_attach_tsv_created (mi_tsv_created
);
1461 observer_attach_tsv_deleted (mi_tsv_deleted
);
1462 observer_attach_tsv_modified (mi_tsv_modified
);
1463 observer_attach_breakpoint_created (mi_breakpoint_created
);
1464 observer_attach_breakpoint_deleted (mi_breakpoint_deleted
);
1465 observer_attach_breakpoint_modified (mi_breakpoint_modified
);
1466 observer_attach_command_param_changed (mi_command_param_changed
);
1467 observer_attach_memory_changed (mi_memory_changed
);
1468 observer_attach_sync_execution_done (mi_on_sync_execution_done
);