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_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
= 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 (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 mi_uiout
->field_string ("reason", async_reason_lookup (reason
));
679 print_stop_event (mi_uiout
);
681 console_interp
= interp_lookup (current_ui
, INTERP_CONSOLE
);
682 if (should_print_stop_to_console (console_interp
, tp
))
683 print_stop_event (mi
->cli_uiout
);
685 mi_uiout
->field_int ("thread-id", tp
->global_num
);
688 struct cleanup
*back_to
= make_cleanup_ui_out_list_begin_end
689 (mi_uiout
, "stopped-threads");
691 mi_uiout
->field_int (NULL
, tp
->global_num
);
692 do_cleanups (back_to
);
695 mi_uiout
->field_string ("stopped-threads", "all");
697 core
= target_core_of_thread (inferior_ptid
);
699 mi_uiout
->field_int ("core", core
);
702 fputs_unfiltered ("*stopped", mi
->raw_stdout
);
703 mi_out_put (mi_uiout
, mi
->raw_stdout
);
704 mi_out_rewind (mi_uiout
);
705 mi_print_timing_maybe (mi
->raw_stdout
);
706 fputs_unfiltered ("\n", mi
->raw_stdout
);
707 gdb_flush (mi
->raw_stdout
);
711 mi_on_normal_stop (struct bpstats
*bs
, int print_frame
)
713 SWITCH_THRU_ALL_UIS ()
715 if (as_mi_interp (top_level_interpreter ()) == NULL
)
718 mi_on_normal_stop_1 (bs
, print_frame
);
723 mi_about_to_proceed (void)
725 /* Suppress output while calling an inferior function. */
727 if (!ptid_equal (inferior_ptid
, null_ptid
))
729 struct thread_info
*tp
= inferior_thread ();
731 if (tp
->control
.in_infcall
)
738 /* When the element is non-zero, no MI notifications will be emitted in
739 response to the corresponding observers. */
741 struct mi_suppress_notification mi_suppress_notification
=
749 /* Emit notification on changing a traceframe. */
752 mi_traceframe_changed (int tfnum
, int tpnum
)
754 if (mi_suppress_notification
.traceframe
)
757 SWITCH_THRU_ALL_UIS ()
759 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
760 struct cleanup
*old_chain
;
765 old_chain
= make_cleanup_restore_target_terminal ();
766 target_terminal_ours_for_output ();
769 fprintf_unfiltered (mi
->event_channel
, "traceframe-changed,"
770 "num=\"%d\",tracepoint=\"%d\"\n",
773 fprintf_unfiltered (mi
->event_channel
, "traceframe-changed,end");
775 gdb_flush (mi
->event_channel
);
777 do_cleanups (old_chain
);
781 /* Emit notification on creating a trace state variable. */
784 mi_tsv_created (const struct trace_state_variable
*tsv
)
786 SWITCH_THRU_ALL_UIS ()
788 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
789 struct cleanup
*old_chain
;
794 old_chain
= make_cleanup_restore_target_terminal ();
795 target_terminal_ours_for_output ();
797 fprintf_unfiltered (mi
->event_channel
, "tsv-created,"
798 "name=\"%s\",initial=\"%s\"\n",
799 tsv
->name
, plongest (tsv
->initial_value
));
801 gdb_flush (mi
->event_channel
);
803 do_cleanups (old_chain
);
807 /* Emit notification on deleting a trace state variable. */
810 mi_tsv_deleted (const struct trace_state_variable
*tsv
)
812 SWITCH_THRU_ALL_UIS ()
814 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
815 struct cleanup
*old_chain
;
820 old_chain
= make_cleanup_restore_target_terminal ();
821 target_terminal_ours_for_output ();
824 fprintf_unfiltered (mi
->event_channel
, "tsv-deleted,"
825 "name=\"%s\"\n", tsv
->name
);
827 fprintf_unfiltered (mi
->event_channel
, "tsv-deleted\n");
829 gdb_flush (mi
->event_channel
);
831 do_cleanups (old_chain
);
835 /* Emit notification on modifying a trace state variable. */
838 mi_tsv_modified (const struct trace_state_variable
*tsv
)
840 SWITCH_THRU_ALL_UIS ()
842 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
843 struct ui_out
*mi_uiout
;
844 struct cleanup
*old_chain
;
849 mi_uiout
= interp_ui_out (top_level_interpreter ());
851 old_chain
= make_cleanup_restore_target_terminal ();
852 target_terminal_ours_for_output ();
854 fprintf_unfiltered (mi
->event_channel
,
857 mi_uiout
->redirect (mi
->event_channel
);
859 mi_uiout
->field_string ("name", tsv
->name
);
860 mi_uiout
->field_string ("initial",
861 plongest (tsv
->initial_value
));
862 if (tsv
->value_known
)
863 mi_uiout
->field_string ("current", plongest (tsv
->value
));
865 mi_uiout
->redirect (NULL
);
867 gdb_flush (mi
->event_channel
);
869 do_cleanups (old_chain
);
873 /* Emit notification about a created breakpoint. */
876 mi_breakpoint_created (struct breakpoint
*b
)
878 if (mi_suppress_notification
.breakpoint
)
884 SWITCH_THRU_ALL_UIS ()
886 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
887 struct ui_out
*mi_uiout
;
888 struct cleanup
*old_chain
;
893 mi_uiout
= interp_ui_out (top_level_interpreter ());
895 old_chain
= make_cleanup_restore_target_terminal ();
896 target_terminal_ours_for_output ();
898 fprintf_unfiltered (mi
->event_channel
,
899 "breakpoint-created");
900 /* We want the output from gdb_breakpoint_query to go to
901 mi->event_channel. One approach would be to just call
902 gdb_breakpoint_query, and then use mi_out_put to send the current
903 content of mi_uiout into mi->event_channel. However, that will
904 break if anything is output to mi_uiout prior to calling the
905 breakpoint_created notifications. So, we use
907 mi_uiout
->redirect (mi
->event_channel
);
910 gdb_breakpoint_query (mi_uiout
, b
->number
, NULL
);
912 CATCH (e
, RETURN_MASK_ERROR
)
917 mi_uiout
->redirect (NULL
);
919 gdb_flush (mi
->event_channel
);
921 do_cleanups (old_chain
);
925 /* Emit notification about deleted breakpoint. */
928 mi_breakpoint_deleted (struct breakpoint
*b
)
930 if (mi_suppress_notification
.breakpoint
)
936 SWITCH_THRU_ALL_UIS ()
938 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
939 struct cleanup
*old_chain
;
944 old_chain
= make_cleanup_restore_target_terminal ();
945 target_terminal_ours_for_output ();
947 fprintf_unfiltered (mi
->event_channel
, "breakpoint-deleted,id=\"%d\"",
950 gdb_flush (mi
->event_channel
);
952 do_cleanups (old_chain
);
956 /* Emit notification about modified breakpoint. */
959 mi_breakpoint_modified (struct breakpoint
*b
)
961 if (mi_suppress_notification
.breakpoint
)
967 SWITCH_THRU_ALL_UIS ()
969 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
970 struct cleanup
*old_chain
;
975 old_chain
= make_cleanup_restore_target_terminal ();
976 target_terminal_ours_for_output ();
977 fprintf_unfiltered (mi
->event_channel
,
978 "breakpoint-modified");
979 /* We want the output from gdb_breakpoint_query to go to
980 mi->event_channel. One approach would be to just call
981 gdb_breakpoint_query, and then use mi_out_put to send the current
982 content of mi_uiout into mi->event_channel. However, that will
983 break if anything is output to mi_uiout prior to calling the
984 breakpoint_created notifications. So, we use
986 mi
->mi_uiout
->redirect (mi
->event_channel
);
989 gdb_breakpoint_query (mi
->mi_uiout
, b
->number
, NULL
);
991 CATCH (e
, RETURN_MASK_ERROR
)
996 mi
->mi_uiout
->redirect (NULL
);
998 gdb_flush (mi
->event_channel
);
1000 do_cleanups (old_chain
);
1005 mi_output_running_pid (struct thread_info
*info
, void *arg
)
1007 ptid_t
*ptid
= (ptid_t
*) arg
;
1009 SWITCH_THRU_ALL_UIS ()
1011 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1016 if (ptid_get_pid (*ptid
) == ptid_get_pid (info
->ptid
))
1017 fprintf_unfiltered (mi
->raw_stdout
,
1018 "*running,thread-id=\"%d\"\n",
1026 mi_inferior_count (struct inferior
*inf
, void *arg
)
1030 int *count_p
= (int *) arg
;
1038 mi_on_resume_1 (struct mi_interp
*mi
, ptid_t ptid
)
1040 /* To cater for older frontends, emit ^running, but do it only once
1041 per each command. We do it here, since at this point we know
1042 that the target was successfully resumed, and in non-async mode,
1043 we won't return back to MI interpreter code until the target
1044 is done running, so delaying the output of "^running" until then
1045 will make it impossible for frontend to know what's going on.
1047 In future (MI3), we'll be outputting "^done" here. */
1048 if (!running_result_record_printed
&& mi_proceeded
)
1050 fprintf_unfiltered (mi
->raw_stdout
, "%s^running\n",
1051 current_token
? current_token
: "");
1054 if (ptid_get_pid (ptid
) == -1)
1055 fprintf_unfiltered (mi
->raw_stdout
, "*running,thread-id=\"all\"\n");
1056 else if (ptid_is_pid (ptid
))
1060 /* Backwards compatibility. If there's only one inferior,
1061 output "all", otherwise, output each resumed thread
1063 iterate_over_inferiors (mi_inferior_count
, &count
);
1066 fprintf_unfiltered (mi
->raw_stdout
, "*running,thread-id=\"all\"\n");
1068 iterate_over_threads (mi_output_running_pid
, &ptid
);
1072 struct thread_info
*ti
= find_thread_ptid (ptid
);
1075 fprintf_unfiltered (mi
->raw_stdout
, "*running,thread-id=\"%d\"\n",
1079 if (!running_result_record_printed
&& mi_proceeded
)
1081 running_result_record_printed
= 1;
1082 /* This is what gdb used to do historically -- printing prompt
1083 even if it cannot actually accept any input. This will be
1084 surely removed for MI3, and may be removed even earlier. */
1085 if (current_ui
->prompt_state
== PROMPT_BLOCKED
)
1086 fputs_unfiltered ("(gdb) \n", mi
->raw_stdout
);
1088 gdb_flush (mi
->raw_stdout
);
1092 mi_on_resume (ptid_t ptid
)
1094 struct thread_info
*tp
= NULL
;
1096 if (ptid_equal (ptid
, minus_one_ptid
) || ptid_is_pid (ptid
))
1097 tp
= inferior_thread ();
1099 tp
= find_thread_ptid (ptid
);
1101 /* Suppress output while calling an inferior function. */
1102 if (tp
->control
.in_infcall
)
1105 SWITCH_THRU_ALL_UIS ()
1107 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1108 struct cleanup
*old_chain
;
1113 old_chain
= make_cleanup_restore_target_terminal ();
1114 target_terminal_ours_for_output ();
1116 mi_on_resume_1 (mi
, ptid
);
1118 do_cleanups (old_chain
);
1123 mi_solib_loaded (struct so_list
*solib
)
1125 SWITCH_THRU_ALL_UIS ()
1127 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1128 struct ui_out
*uiout
;
1129 struct cleanup
*old_chain
;
1134 uiout
= interp_ui_out (top_level_interpreter ());
1136 old_chain
= make_cleanup_restore_target_terminal ();
1137 target_terminal_ours_for_output ();
1139 fprintf_unfiltered (mi
->event_channel
, "library-loaded");
1141 uiout
->redirect (mi
->event_channel
);
1143 uiout
->field_string ("id", solib
->so_original_name
);
1144 uiout
->field_string ("target-name", solib
->so_original_name
);
1145 uiout
->field_string ("host-name", solib
->so_name
);
1146 uiout
->field_int ("symbols-loaded", solib
->symbols_loaded
);
1147 if (!gdbarch_has_global_solist (target_gdbarch ()))
1149 uiout
->field_fmt ("thread-group", "i%d", current_inferior ()->num
);
1152 uiout
->redirect (NULL
);
1154 gdb_flush (mi
->event_channel
);
1156 do_cleanups (old_chain
);
1161 mi_solib_unloaded (struct so_list
*solib
)
1163 SWITCH_THRU_ALL_UIS ()
1165 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1166 struct ui_out
*uiout
;
1167 struct cleanup
*old_chain
;
1172 uiout
= interp_ui_out (top_level_interpreter ());
1174 old_chain
= make_cleanup_restore_target_terminal ();
1175 target_terminal_ours_for_output ();
1177 fprintf_unfiltered (mi
->event_channel
, "library-unloaded");
1179 uiout
->redirect (mi
->event_channel
);
1181 uiout
->field_string ("id", solib
->so_original_name
);
1182 uiout
->field_string ("target-name", solib
->so_original_name
);
1183 uiout
->field_string ("host-name", solib
->so_name
);
1184 if (!gdbarch_has_global_solist (target_gdbarch ()))
1186 uiout
->field_fmt ("thread-group", "i%d", current_inferior ()->num
);
1189 uiout
->redirect (NULL
);
1191 gdb_flush (mi
->event_channel
);
1193 do_cleanups (old_chain
);
1197 /* Emit notification about the command parameter change. */
1200 mi_command_param_changed (const char *param
, const char *value
)
1202 if (mi_suppress_notification
.cmd_param_changed
)
1205 SWITCH_THRU_ALL_UIS ()
1207 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1208 struct ui_out
*mi_uiout
;
1209 struct cleanup
*old_chain
;
1214 mi_uiout
= interp_ui_out (top_level_interpreter ());
1216 old_chain
= make_cleanup_restore_target_terminal ();
1217 target_terminal_ours_for_output ();
1219 fprintf_unfiltered (mi
->event_channel
, "cmd-param-changed");
1221 mi_uiout
->redirect (mi
->event_channel
);
1223 mi_uiout
->field_string ("param", param
);
1224 mi_uiout
->field_string ("value", value
);
1226 mi_uiout
->redirect (NULL
);
1228 gdb_flush (mi
->event_channel
);
1230 do_cleanups (old_chain
);
1234 /* Emit notification about the target memory change. */
1237 mi_memory_changed (struct inferior
*inferior
, CORE_ADDR memaddr
,
1238 ssize_t len
, const bfd_byte
*myaddr
)
1240 if (mi_suppress_notification
.memory
)
1243 SWITCH_THRU_ALL_UIS ()
1245 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1246 struct ui_out
*mi_uiout
;
1247 struct obj_section
*sec
;
1248 struct cleanup
*old_chain
;
1253 mi_uiout
= interp_ui_out (top_level_interpreter ());
1255 old_chain
= make_cleanup_restore_target_terminal ();
1256 target_terminal_ours_for_output ();
1258 fprintf_unfiltered (mi
->event_channel
, "memory-changed");
1260 mi_uiout
->redirect (mi
->event_channel
);
1262 mi_uiout
->field_fmt ("thread-group", "i%d", inferior
->num
);
1263 mi_uiout
->field_core_addr ("addr", target_gdbarch (), memaddr
);
1264 mi_uiout
->field_fmt ("len", "%s", hex_string (len
));
1266 /* Append 'type=code' into notification if MEMADDR falls in the range of
1267 sections contain code. */
1268 sec
= find_pc_section (memaddr
);
1269 if (sec
!= NULL
&& sec
->objfile
!= NULL
)
1271 flagword flags
= bfd_get_section_flags (sec
->objfile
->obfd
,
1272 sec
->the_bfd_section
);
1274 if (flags
& SEC_CODE
)
1275 mi_uiout
->field_string ("type", "code");
1278 mi_uiout
->redirect (NULL
);
1280 gdb_flush (mi
->event_channel
);
1282 do_cleanups (old_chain
);
1286 /* Emit an event when the selection context (inferior, thread, frame)
1290 mi_user_selected_context_changed (user_selected_what selection
)
1292 struct thread_info
*tp
;
1294 /* Don't send an event if we're responding to an MI command. */
1295 if (mi_suppress_notification
.user_selected_context
)
1298 tp
= find_thread_ptid (inferior_ptid
);
1300 SWITCH_THRU_ALL_UIS ()
1302 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1303 struct ui_out
*mi_uiout
;
1304 struct cleanup
*old_chain
;
1309 mi_uiout
= interp_ui_out (top_level_interpreter ());
1311 mi_uiout
->redirect (mi
->event_channel
);
1313 old_chain
= make_cleanup_ui_out_redirect_pop (mi_uiout
);
1315 make_cleanup_restore_target_terminal ();
1316 target_terminal_ours_for_output ();
1318 if (selection
& USER_SELECTED_INFERIOR
)
1319 print_selected_inferior (mi
->cli_uiout
);
1322 && (selection
& (USER_SELECTED_THREAD
| USER_SELECTED_FRAME
)))
1324 print_selected_thread_frame (mi
->cli_uiout
, selection
);
1326 fprintf_unfiltered (mi
->event_channel
,
1327 "thread-selected,id=\"%d\"",
1330 if (tp
->state
!= THREAD_RUNNING
)
1332 if (has_stack_frames ())
1333 print_stack_frame_to_uiout (mi_uiout
, get_selected_frame (NULL
),
1338 gdb_flush (mi
->event_channel
);
1339 do_cleanups (old_chain
);
1344 report_initial_inferior (struct inferior
*inf
, void *closure
)
1346 /* This function is called from mi_interpreter_init, and since
1347 mi_inferior_added assumes that inferior is fully initialized
1348 and top_level_interpreter_data is set, we cannot call
1350 struct mi_interp
*mi
= (struct mi_interp
*) closure
;
1351 struct cleanup
*old_chain
;
1353 old_chain
= make_cleanup_restore_target_terminal ();
1354 target_terminal_ours_for_output ();
1356 fprintf_unfiltered (mi
->event_channel
,
1357 "thread-group-added,id=\"i%d\"",
1359 gdb_flush (mi
->event_channel
);
1361 do_cleanups (old_chain
);
1365 static struct ui_out
*
1366 mi_ui_out (struct interp
*interp
)
1368 struct mi_interp
*mi
= (struct mi_interp
*) interp_data (interp
);
1370 return mi
->mi_uiout
;
1373 /* Do MI-specific logging actions; save raw_stdout, and change all
1374 the consoles to use the supplied ui-file(s). */
1377 mi_set_logging (struct interp
*interp
,
1378 ui_file_up logfile
, bool logging_redirect
)
1380 struct mi_interp
*mi
= (struct mi_interp
*) interp_data (interp
);
1382 gdb_assert (mi
!= NULL
);
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 /* The MI interpreter's vtable. */
1408 static const struct interp_procs mi_interp_procs
=
1410 mi_interpreter_init
, /* init_proc */
1411 mi_interpreter_resume
, /* resume_proc */
1412 mi_interpreter_suspend
, /* suspend_proc */
1413 mi_interpreter_exec
, /* exec_proc */
1414 mi_ui_out
, /* ui_out_proc */
1415 mi_set_logging
, /* set_logging_proc */
1416 mi_interpreter_pre_command_loop
/* pre_command_loop_proc */
1419 /* Factory for MI interpreters. */
1421 static struct interp
*
1422 mi_interp_factory (const char *name
)
1424 return interp_new (name
, &mi_interp_procs
, NULL
);
1427 extern initialize_file_ftype _initialize_mi_interp
; /* -Wmissing-prototypes */
1430 _initialize_mi_interp (void)
1432 /* The various interpreter levels. */
1433 interp_factory_register (INTERP_MI1
, mi_interp_factory
);
1434 interp_factory_register (INTERP_MI2
, mi_interp_factory
);
1435 interp_factory_register (INTERP_MI3
, mi_interp_factory
);
1436 interp_factory_register (INTERP_MI
, mi_interp_factory
);
1438 observer_attach_signal_received (mi_on_signal_received
);
1439 observer_attach_end_stepping_range (mi_on_end_stepping_range
);
1440 observer_attach_signal_exited (mi_on_signal_exited
);
1441 observer_attach_exited (mi_on_exited
);
1442 observer_attach_no_history (mi_on_no_history
);
1443 observer_attach_new_thread (mi_new_thread
);
1444 observer_attach_thread_exit (mi_thread_exit
);
1445 observer_attach_inferior_added (mi_inferior_added
);
1446 observer_attach_inferior_appeared (mi_inferior_appeared
);
1447 observer_attach_inferior_exit (mi_inferior_exit
);
1448 observer_attach_inferior_removed (mi_inferior_removed
);
1449 observer_attach_record_changed (mi_record_changed
);
1450 observer_attach_normal_stop (mi_on_normal_stop
);
1451 observer_attach_target_resumed (mi_on_resume
);
1452 observer_attach_solib_loaded (mi_solib_loaded
);
1453 observer_attach_solib_unloaded (mi_solib_unloaded
);
1454 observer_attach_about_to_proceed (mi_about_to_proceed
);
1455 observer_attach_traceframe_changed (mi_traceframe_changed
);
1456 observer_attach_tsv_created (mi_tsv_created
);
1457 observer_attach_tsv_deleted (mi_tsv_deleted
);
1458 observer_attach_tsv_modified (mi_tsv_modified
);
1459 observer_attach_breakpoint_created (mi_breakpoint_created
);
1460 observer_attach_breakpoint_deleted (mi_breakpoint_deleted
);
1461 observer_attach_breakpoint_modified (mi_breakpoint_modified
);
1462 observer_attach_command_param_changed (mi_command_param_changed
);
1463 observer_attach_memory_changed (mi_memory_changed
);
1464 observer_attach_sync_execution_done (mi_on_sync_execution_done
);
1465 observer_attach_user_selected_context_changed
1466 (mi_user_selected_context_changed
);