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"
42 /* These are the interpreter setup, etc. functions for the MI
45 static void mi_execute_command_wrapper (const char *cmd
);
46 static void mi_execute_command_input_handler (char *cmd
);
47 static void mi_command_loop (void *data
);
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 (void)
97 fputs_unfiltered ("(gdb) \n", raw_stdout
);
98 gdb_flush (raw_stdout
);
101 /* Returns the INTERP's data cast as mi_interp if INTERP is an MI, and
102 returns NULL otherwise. */
104 static struct mi_interp
*
105 as_mi_interp (struct interp
*interp
)
107 if (ui_out_is_mi_like_p (interp_ui_out (interp
)))
108 return (struct mi_interp
*) interp_data (interp
);
113 mi_interpreter_init (struct interp
*interp
, int top_level
)
115 struct mi_interp
*mi
= XNEW (struct mi_interp
);
119 /* Assign the output channel created at startup to its own global,
120 so that we can create a console channel that encapsulates and
121 prefixes all gdb_output-type bits coming from the rest of the
124 raw_stdout
= gdb_stdout
;
126 /* Create MI console channels, each with a different prefix so they
127 can be distinguished. */
128 mi
->out
= mi_console_file_new (raw_stdout
, "~", '"');
129 mi
->err
= mi_console_file_new (raw_stdout
, "&", '"');
131 mi
->targ
= mi_console_file_new (raw_stdout
, "@", '"');
132 mi
->event_channel
= mi_console_file_new (raw_stdout
, "=", 0);
134 name
= interp_name (interp
);
135 /* INTERP_MI selects the most recent released version. "mi2" was
136 released as part of GDB 6.0. */
137 if (strcmp (name
, INTERP_MI
) == 0)
139 else if (strcmp (name
, INTERP_MI1
) == 0)
141 else if (strcmp (name
, INTERP_MI2
) == 0)
143 else if (strcmp (name
, INTERP_MI3
) == 0)
146 gdb_assert_not_reached ("unhandled MI version");
148 mi
->mi_uiout
= mi_out_new (mi_version
);
149 mi
->cli_uiout
= cli_out_new (mi
->out
);
153 /* The initial inferior is created before this function is
154 called, so we need to report it explicitly. Use iteration in
155 case future version of GDB creates more than one inferior
157 iterate_over_inferiors (report_initial_inferior
, mi
);
164 mi_interpreter_resume (void *data
)
166 struct mi_interp
*mi
= (struct mi_interp
*) data
;
167 struct ui
*ui
= current_ui
;
169 /* As per hack note in mi_interpreter_init, swap in the output
171 gdb_setup_readline (0);
173 ui
->call_readline
= gdb_readline_no_editing_callback
;
174 ui
->input_handler
= mi_execute_command_input_handler
;
175 /* FIXME: This is a total hack for now. PB's use of the MI
176 implicitly relies on a bug in the async support which allows
177 asynchronous commands to leak through the commmand loop. The bug
178 involves (but is not limited to) the fact that sync_execution was
179 erroneously initialized to 0. Duplicate by initializing it thus
183 gdb_stdout
= mi
->out
;
184 /* Route error and log output through the MI. */
185 gdb_stderr
= mi
->err
;
186 gdb_stdlog
= mi
->log
;
187 /* Route target output through the MI. */
188 gdb_stdtarg
= mi
->targ
;
189 /* Route target error through the MI as well. */
190 gdb_stdtargerr
= mi
->targ
;
192 /* Replace all the hooks that we know about. There really needs to
193 be a better way of doing this... */
194 clear_interpreter_hooks ();
196 deprecated_show_load_progress
= mi_load_progress
;
202 mi_interpreter_suspend (void *data
)
204 gdb_disable_readline ();
208 static struct gdb_exception
209 mi_interpreter_exec (void *data
, const char *command
)
211 mi_execute_command_wrapper (command
);
212 return exception_none
;
216 mi_cmd_interpreter_exec (char *command
, char **argv
, int argc
)
218 struct interp
*interp_to_use
;
220 char *mi_error_message
= NULL
;
221 struct cleanup
*old_chain
;
224 error (_("-interpreter-exec: "
225 "Usage: -interpreter-exec interp command"));
227 interp_to_use
= interp_lookup (current_ui
, argv
[0]);
228 if (interp_to_use
== NULL
)
229 error (_("-interpreter-exec: could not find interpreter \"%s\""),
232 /* Note that unlike the CLI version of this command, we don't
233 actually set INTERP_TO_USE as the current interpreter, as we
234 still want gdb_stdout, etc. to point at MI streams. */
236 /* Insert the MI out hooks, making sure to also call the
237 interpreter's hooks if it has any. */
238 /* KRS: We shouldn't need this... Events should be installed and
239 they should just ALWAYS fire something out down the MI
241 mi_insert_notify_hooks ();
243 /* Now run the code. */
245 old_chain
= make_cleanup (null_cleanup
, 0);
246 for (i
= 1; i
< argc
; i
++)
248 struct gdb_exception e
= interp_exec (interp_to_use
, argv
[i
]);
252 mi_error_message
= xstrdup (e
.message
);
253 make_cleanup (xfree
, mi_error_message
);
258 mi_remove_notify_hooks ();
260 if (mi_error_message
!= NULL
)
261 error ("%s", mi_error_message
);
262 do_cleanups (old_chain
);
265 /* This inserts a number of hooks that are meant to produce
266 async-notify ("=") MI messages while running commands in another
267 interpreter using mi_interpreter_exec. The canonical use for this
268 is to allow access to the gdb CLI interpreter from within the MI,
269 while still producing MI style output when actions in the CLI
270 command change GDB's state. */
273 mi_insert_notify_hooks (void)
275 deprecated_query_hook
= mi_interp_query_hook
;
279 mi_remove_notify_hooks (void)
281 deprecated_query_hook
= NULL
;
285 mi_interp_query_hook (const char *ctlstr
, va_list ap
)
291 mi_execute_command_wrapper (const char *cmd
)
293 struct ui
*ui
= current_ui
;
295 mi_execute_command (cmd
, stdin
== ui
->instream
);
298 /* Observer for the synchronous_command_done notification. */
301 mi_on_sync_execution_done (void)
303 struct ui
*ui
= current_ui
;
304 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
309 /* If MI is sync, then output the MI prompt now, indicating we're
310 ready for further input. */
312 display_mi_prompt ();
315 /* mi_execute_command_wrapper wrapper suitable for INPUT_HANDLER. */
318 mi_execute_command_input_handler (char *cmd
)
320 mi_execute_command_wrapper (cmd
);
322 /* Print a prompt, indicating we're ready for further input, unless
323 we just started a synchronous command. In that case, we're about
324 to go back to the event loop and will output the prompt in the
325 'synchronous_command_done' observer when the target next
328 display_mi_prompt ();
332 mi_command_loop (void *data
)
334 /* Turn off 8 bit strings in quoted output. Any character with the
335 high bit set is printed using C's octal format. */
336 sevenbit_strings
= 1;
338 /* Tell the world that we're alive. */
339 display_mi_prompt ();
345 mi_new_thread (struct thread_info
*t
)
347 struct inferior
*inf
= find_inferior_ptid (t
->ptid
);
348 struct switch_thru_all_uis state
;
352 SWITCH_THRU_ALL_UIS (state
)
354 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
355 struct cleanup
*old_chain
;
360 old_chain
= make_cleanup_restore_target_terminal ();
361 target_terminal_ours_for_output ();
363 fprintf_unfiltered (mi
->event_channel
,
364 "thread-created,id=\"%d\",group-id=\"i%d\"",
365 t
->global_num
, inf
->num
);
366 gdb_flush (mi
->event_channel
);
368 do_cleanups (old_chain
);
373 mi_thread_exit (struct thread_info
*t
, int silent
)
375 struct switch_thru_all_uis state
;
380 SWITCH_THRU_ALL_UIS (state
)
382 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
383 struct cleanup
*old_chain
;
388 old_chain
= make_cleanup_restore_target_terminal ();
389 target_terminal_ours_for_output ();
390 fprintf_unfiltered (mi
->event_channel
,
391 "thread-exited,id=\"%d\",group-id=\"i%d\"",
392 t
->global_num
, t
->inf
->num
);
393 gdb_flush (mi
->event_channel
);
395 do_cleanups (old_chain
);
399 /* Emit notification on changing the state of record. */
402 mi_record_changed (struct inferior
*inferior
, int started
, const char *method
,
405 struct switch_thru_all_uis state
;
407 SWITCH_THRU_ALL_UIS (state
)
409 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
410 struct cleanup
*old_chain
;
415 old_chain
= make_cleanup_restore_target_terminal ();
416 target_terminal_ours_for_output ();
422 fprintf_unfiltered (mi
->event_channel
,
423 "record-started,thread-group=\"i%d\","
424 "method=\"%s\",format=\"%s\"",
425 inferior
->num
, method
, format
);
429 fprintf_unfiltered (mi
->event_channel
,
430 "record-started,thread-group=\"i%d\","
432 inferior
->num
, method
);
437 fprintf_unfiltered (mi
->event_channel
,
438 "record-stopped,thread-group=\"i%d\"",
442 gdb_flush (mi
->event_channel
);
444 do_cleanups (old_chain
);
449 mi_inferior_added (struct inferior
*inf
)
451 struct switch_thru_all_uis state
;
453 SWITCH_THRU_ALL_UIS (state
)
455 struct interp
*interp
;
456 struct mi_interp
*mi
;
457 struct cleanup
*old_chain
;
459 /* We'll be called once for the initial inferior, before the top
460 level interpreter is set. */
461 interp
= top_level_interpreter ();
465 mi
= as_mi_interp (interp
);
469 old_chain
= make_cleanup_restore_target_terminal ();
470 target_terminal_ours_for_output ();
472 fprintf_unfiltered (mi
->event_channel
,
473 "thread-group-added,id=\"i%d\"",
475 gdb_flush (mi
->event_channel
);
477 do_cleanups (old_chain
);
482 mi_inferior_appeared (struct inferior
*inf
)
484 struct switch_thru_all_uis state
;
486 SWITCH_THRU_ALL_UIS (state
)
488 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
489 struct cleanup
*old_chain
;
494 old_chain
= make_cleanup_restore_target_terminal ();
495 target_terminal_ours_for_output ();
497 fprintf_unfiltered (mi
->event_channel
,
498 "thread-group-started,id=\"i%d\",pid=\"%d\"",
500 gdb_flush (mi
->event_channel
);
501 do_cleanups (old_chain
);
506 mi_inferior_exit (struct inferior
*inf
)
508 struct switch_thru_all_uis state
;
510 SWITCH_THRU_ALL_UIS (state
)
512 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
513 struct cleanup
*old_chain
;
518 old_chain
= make_cleanup_restore_target_terminal ();
519 target_terminal_ours_for_output ();
521 if (inf
->has_exit_code
)
522 fprintf_unfiltered (mi
->event_channel
,
523 "thread-group-exited,id=\"i%d\",exit-code=\"%s\"",
524 inf
->num
, int_string (inf
->exit_code
, 8, 0, 0, 1));
526 fprintf_unfiltered (mi
->event_channel
,
527 "thread-group-exited,id=\"i%d\"", inf
->num
);
529 gdb_flush (mi
->event_channel
);
530 do_cleanups (old_chain
);
535 mi_inferior_removed (struct inferior
*inf
)
537 struct switch_thru_all_uis state
;
539 SWITCH_THRU_ALL_UIS (state
)
541 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
542 struct cleanup
*old_chain
;
547 old_chain
= make_cleanup_restore_target_terminal ();
548 target_terminal_ours_for_output ();
550 fprintf_unfiltered (mi
->event_channel
,
551 "thread-group-removed,id=\"i%d\"",
553 gdb_flush (mi
->event_channel
);
555 do_cleanups (old_chain
);
559 /* Return the MI interpreter, if it is active -- either because it's
560 the top-level interpreter or the interpreter executing the current
561 command. Returns NULL if the MI interpreter is not being used. */
563 static struct mi_interp
*
564 find_mi_interp (void)
566 struct mi_interp
*mi
;
568 mi
= as_mi_interp (top_level_interpreter ());
572 mi
= as_mi_interp (command_interp ());
579 /* Observers for several run control events that print why the
580 inferior has stopped to both the the MI event channel and to the MI
581 console. If the MI interpreter is not active, print nothing. */
583 /* Observer for the signal_received notification. */
586 mi_on_signal_received (enum gdb_signal siggnal
)
588 struct switch_thru_all_uis state
;
590 SWITCH_THRU_ALL_UIS (state
)
592 struct mi_interp
*mi
= find_mi_interp ();
597 print_signal_received_reason (mi
->mi_uiout
, siggnal
);
598 print_signal_received_reason (mi
->cli_uiout
, siggnal
);
602 /* Observer for the end_stepping_range notification. */
605 mi_on_end_stepping_range (void)
607 struct switch_thru_all_uis state
;
609 SWITCH_THRU_ALL_UIS (state
)
611 struct mi_interp
*mi
= find_mi_interp ();
616 print_end_stepping_range_reason (mi
->mi_uiout
);
617 print_end_stepping_range_reason (mi
->cli_uiout
);
621 /* Observer for the signal_exited notification. */
624 mi_on_signal_exited (enum gdb_signal siggnal
)
626 struct switch_thru_all_uis state
;
628 SWITCH_THRU_ALL_UIS (state
)
630 struct mi_interp
*mi
= find_mi_interp ();
635 print_signal_exited_reason (mi
->mi_uiout
, siggnal
);
636 print_signal_exited_reason (mi
->cli_uiout
, siggnal
);
640 /* Observer for the exited notification. */
643 mi_on_exited (int exitstatus
)
645 struct switch_thru_all_uis state
;
647 SWITCH_THRU_ALL_UIS (state
)
649 struct mi_interp
*mi
= find_mi_interp ();
654 print_exited_reason (mi
->mi_uiout
, exitstatus
);
655 print_exited_reason (mi
->cli_uiout
, exitstatus
);
659 /* Observer for the no_history notification. */
662 mi_on_no_history (void)
664 struct switch_thru_all_uis state
;
666 SWITCH_THRU_ALL_UIS (state
)
668 struct mi_interp
*mi
= find_mi_interp ();
673 print_no_history_reason (mi
->mi_uiout
);
674 print_no_history_reason (mi
->cli_uiout
);
679 mi_on_normal_stop_1 (struct bpstats
*bs
, int print_frame
)
681 /* Since this can be called when CLI command is executing,
682 using cli interpreter, be sure to use MI uiout for output,
683 not the current one. */
684 struct ui_out
*mi_uiout
= interp_ui_out (top_level_interpreter ());
688 struct thread_info
*tp
;
691 tp
= inferior_thread ();
693 if (tp
->thread_fsm
!= NULL
694 && thread_fsm_finished_p (tp
->thread_fsm
))
696 enum async_reply_reason reason
;
698 reason
= thread_fsm_async_reply_reason (tp
->thread_fsm
);
699 ui_out_field_string (mi_uiout
, "reason",
700 async_reason_lookup (reason
));
702 print_stop_event (mi_uiout
);
704 /* Breakpoint hits should always be mirrored to the console.
705 Deciding what to mirror to the console wrt to breakpoints and
706 random stops gets messy real fast. E.g., say "s" trips on a
707 breakpoint. We'd clearly want to mirror the event to the
708 console in this case. But what about more complicated cases
709 like "s&; thread n; s&", and one of those steps spawning a
710 new thread, and that thread hitting a breakpoint? It's
711 impossible in general to track whether the thread had any
712 relation to the commands that had been executed. So we just
713 simplify and always mirror breakpoints and random events to
716 OTOH, we should print the source line to the console when
717 stepping or other similar commands, iff the step was started
718 by a console command, but not if it was started with
719 -exec-step or similar. */
720 if ((bpstat_what (tp
->control
.stop_bpstat
).main_action
721 == BPSTAT_WHAT_STOP_NOISY
)
722 || !(tp
->thread_fsm
!= NULL
723 && thread_fsm_finished_p (tp
->thread_fsm
))
724 || (tp
->control
.command_interp
!= NULL
725 && tp
->control
.command_interp
!= top_level_interpreter ()))
728 = (struct mi_interp
*) top_level_interpreter_data ();
730 print_stop_event (mi
->cli_uiout
);
733 tp
= inferior_thread ();
734 ui_out_field_int (mi_uiout
, "thread-id", tp
->global_num
);
737 struct cleanup
*back_to
= make_cleanup_ui_out_list_begin_end
738 (mi_uiout
, "stopped-threads");
740 ui_out_field_int (mi_uiout
, NULL
, tp
->global_num
);
741 do_cleanups (back_to
);
744 ui_out_field_string (mi_uiout
, "stopped-threads", "all");
746 core
= target_core_of_thread (inferior_ptid
);
748 ui_out_field_int (mi_uiout
, "core", core
);
751 fputs_unfiltered ("*stopped", raw_stdout
);
752 mi_out_put (mi_uiout
, raw_stdout
);
753 mi_out_rewind (mi_uiout
);
754 mi_print_timing_maybe ();
755 fputs_unfiltered ("\n", raw_stdout
);
756 gdb_flush (raw_stdout
);
760 mi_on_normal_stop (struct bpstats
*bs
, int print_frame
)
762 struct switch_thru_all_uis state
;
764 SWITCH_THRU_ALL_UIS (state
)
766 if (as_mi_interp (top_level_interpreter ()) == NULL
)
769 mi_on_normal_stop_1 (bs
, print_frame
);
774 mi_about_to_proceed (void)
776 /* Suppress output while calling an inferior function. */
778 if (!ptid_equal (inferior_ptid
, null_ptid
))
780 struct thread_info
*tp
= inferior_thread ();
782 if (tp
->control
.in_infcall
)
789 /* When the element is non-zero, no MI notifications will be emitted in
790 response to the corresponding observers. */
792 struct mi_suppress_notification mi_suppress_notification
=
799 /* Emit notification on changing a traceframe. */
802 mi_traceframe_changed (int tfnum
, int tpnum
)
804 struct switch_thru_all_uis state
;
806 if (mi_suppress_notification
.traceframe
)
809 SWITCH_THRU_ALL_UIS (state
)
811 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
812 struct cleanup
*old_chain
;
817 old_chain
= make_cleanup_restore_target_terminal ();
818 target_terminal_ours_for_output ();
821 fprintf_unfiltered (mi
->event_channel
, "traceframe-changed,"
822 "num=\"%d\",tracepoint=\"%d\"\n",
825 fprintf_unfiltered (mi
->event_channel
, "traceframe-changed,end");
827 gdb_flush (mi
->event_channel
);
829 do_cleanups (old_chain
);
833 /* Emit notification on creating a trace state variable. */
836 mi_tsv_created (const struct trace_state_variable
*tsv
)
838 struct switch_thru_all_uis state
;
840 SWITCH_THRU_ALL_UIS (state
)
842 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
843 struct cleanup
*old_chain
;
848 old_chain
= make_cleanup_restore_target_terminal ();
849 target_terminal_ours_for_output ();
851 fprintf_unfiltered (mi
->event_channel
, "tsv-created,"
852 "name=\"%s\",initial=\"%s\"\n",
853 tsv
->name
, plongest (tsv
->initial_value
));
855 gdb_flush (mi
->event_channel
);
857 do_cleanups (old_chain
);
861 /* Emit notification on deleting a trace state variable. */
864 mi_tsv_deleted (const struct trace_state_variable
*tsv
)
866 struct switch_thru_all_uis state
;
868 SWITCH_THRU_ALL_UIS (state
)
870 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
871 struct cleanup
*old_chain
;
876 old_chain
= make_cleanup_restore_target_terminal ();
877 target_terminal_ours_for_output ();
880 fprintf_unfiltered (mi
->event_channel
, "tsv-deleted,"
881 "name=\"%s\"\n", tsv
->name
);
883 fprintf_unfiltered (mi
->event_channel
, "tsv-deleted\n");
885 gdb_flush (mi
->event_channel
);
887 do_cleanups (old_chain
);
891 /* Emit notification on modifying a trace state variable. */
894 mi_tsv_modified (const struct trace_state_variable
*tsv
)
896 struct switch_thru_all_uis state
;
898 SWITCH_THRU_ALL_UIS (state
)
900 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
901 struct ui_out
*mi_uiout
;
902 struct cleanup
*old_chain
;
907 mi_uiout
= interp_ui_out (top_level_interpreter ());
909 old_chain
= make_cleanup_restore_target_terminal ();
910 target_terminal_ours_for_output ();
912 fprintf_unfiltered (mi
->event_channel
,
915 ui_out_redirect (mi_uiout
, mi
->event_channel
);
917 ui_out_field_string (mi_uiout
, "name", tsv
->name
);
918 ui_out_field_string (mi_uiout
, "initial",
919 plongest (tsv
->initial_value
));
920 if (tsv
->value_known
)
921 ui_out_field_string (mi_uiout
, "current", plongest (tsv
->value
));
923 ui_out_redirect (mi_uiout
, NULL
);
925 gdb_flush (mi
->event_channel
);
927 do_cleanups (old_chain
);
931 /* Emit notification about a created breakpoint. */
934 mi_breakpoint_created (struct breakpoint
*b
)
936 struct switch_thru_all_uis state
;
938 if (mi_suppress_notification
.breakpoint
)
944 SWITCH_THRU_ALL_UIS (state
)
946 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
947 struct ui_out
*mi_uiout
;
948 struct cleanup
*old_chain
;
953 mi_uiout
= interp_ui_out (top_level_interpreter ());
955 old_chain
= make_cleanup_restore_target_terminal ();
956 target_terminal_ours_for_output ();
958 fprintf_unfiltered (mi
->event_channel
,
959 "breakpoint-created");
960 /* We want the output from gdb_breakpoint_query to go to
961 mi->event_channel. One approach would be to just call
962 gdb_breakpoint_query, and then use mi_out_put to send the current
963 content of mi_outout into mi->event_channel. However, that will
964 break if anything is output to mi_uiout prior to calling the
965 breakpoint_created notifications. So, we use
967 ui_out_redirect (mi_uiout
, mi
->event_channel
);
970 gdb_breakpoint_query (mi_uiout
, b
->number
, NULL
);
972 CATCH (e
, RETURN_MASK_ERROR
)
977 ui_out_redirect (mi_uiout
, NULL
);
979 gdb_flush (mi
->event_channel
);
981 do_cleanups (old_chain
);
985 /* Emit notification about deleted breakpoint. */
988 mi_breakpoint_deleted (struct breakpoint
*b
)
990 struct switch_thru_all_uis state
;
992 if (mi_suppress_notification
.breakpoint
)
998 SWITCH_THRU_ALL_UIS (state
)
1000 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1001 struct cleanup
*old_chain
;
1006 old_chain
= make_cleanup_restore_target_terminal ();
1007 target_terminal_ours_for_output ();
1009 fprintf_unfiltered (mi
->event_channel
, "breakpoint-deleted,id=\"%d\"",
1012 gdb_flush (mi
->event_channel
);
1014 do_cleanups (old_chain
);
1018 /* Emit notification about modified breakpoint. */
1021 mi_breakpoint_modified (struct breakpoint
*b
)
1023 struct switch_thru_all_uis state
;
1025 if (mi_suppress_notification
.breakpoint
)
1031 SWITCH_THRU_ALL_UIS (state
)
1033 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1034 struct cleanup
*old_chain
;
1039 old_chain
= make_cleanup_restore_target_terminal ();
1040 target_terminal_ours_for_output ();
1041 fprintf_unfiltered (mi
->event_channel
,
1042 "breakpoint-modified");
1043 /* We want the output from gdb_breakpoint_query to go to
1044 mi->event_channel. One approach would be to just call
1045 gdb_breakpoint_query, and then use mi_out_put to send the current
1046 content of mi_outout into mi->event_channel. However, that will
1047 break if anything is output to mi_uiout prior to calling the
1048 breakpoint_created notifications. So, we use
1050 ui_out_redirect (mi
->mi_uiout
, mi
->event_channel
);
1053 gdb_breakpoint_query (mi
->mi_uiout
, b
->number
, NULL
);
1055 CATCH (e
, RETURN_MASK_ERROR
)
1060 ui_out_redirect (mi
->mi_uiout
, NULL
);
1062 gdb_flush (mi
->event_channel
);
1064 do_cleanups (old_chain
);
1069 mi_output_running_pid (struct thread_info
*info
, void *arg
)
1071 ptid_t
*ptid
= (ptid_t
*) arg
;
1072 struct switch_thru_all_uis state
;
1074 SWITCH_THRU_ALL_UIS (state
)
1076 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1081 if (ptid_get_pid (*ptid
) == ptid_get_pid (info
->ptid
))
1082 fprintf_unfiltered (raw_stdout
,
1083 "*running,thread-id=\"%d\"\n",
1091 mi_inferior_count (struct inferior
*inf
, void *arg
)
1095 int *count_p
= (int *) arg
;
1103 mi_on_resume_1 (ptid_t ptid
)
1105 /* To cater for older frontends, emit ^running, but do it only once
1106 per each command. We do it here, since at this point we know
1107 that the target was successfully resumed, and in non-async mode,
1108 we won't return back to MI interpreter code until the target
1109 is done running, so delaying the output of "^running" until then
1110 will make it impossible for frontend to know what's going on.
1112 In future (MI3), we'll be outputting "^done" here. */
1113 if (!running_result_record_printed
&& mi_proceeded
)
1115 fprintf_unfiltered (raw_stdout
, "%s^running\n",
1116 current_token
? current_token
: "");
1119 if (ptid_get_pid (ptid
) == -1)
1120 fprintf_unfiltered (raw_stdout
, "*running,thread-id=\"all\"\n");
1121 else if (ptid_is_pid (ptid
))
1125 /* Backwards compatibility. If there's only one inferior,
1126 output "all", otherwise, output each resumed thread
1128 iterate_over_inferiors (mi_inferior_count
, &count
);
1131 fprintf_unfiltered (raw_stdout
, "*running,thread-id=\"all\"\n");
1133 iterate_over_threads (mi_output_running_pid
, &ptid
);
1137 struct thread_info
*ti
= find_thread_ptid (ptid
);
1140 fprintf_unfiltered (raw_stdout
, "*running,thread-id=\"%d\"\n",
1144 if (!running_result_record_printed
&& mi_proceeded
)
1146 running_result_record_printed
= 1;
1147 /* This is what gdb used to do historically -- printing prompt even if
1148 it cannot actually accept any input. This will be surely removed
1149 for MI3, and may be removed even earlier. SYNC_EXECUTION is
1150 checked here because we only need to emit a prompt if a
1151 synchronous command was issued when the target is async. */
1152 if (!target_can_async_p () || sync_execution
)
1153 fputs_unfiltered ("(gdb) \n", raw_stdout
);
1155 gdb_flush (raw_stdout
);
1159 mi_on_resume (ptid_t ptid
)
1161 struct thread_info
*tp
= NULL
;
1162 struct switch_thru_all_uis state
;
1164 if (ptid_equal (ptid
, minus_one_ptid
) || ptid_is_pid (ptid
))
1165 tp
= inferior_thread ();
1167 tp
= find_thread_ptid (ptid
);
1169 /* Suppress output while calling an inferior function. */
1170 if (tp
->control
.in_infcall
)
1173 SWITCH_THRU_ALL_UIS (state
)
1175 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1176 struct cleanup
*old_chain
;
1181 old_chain
= make_cleanup_restore_target_terminal ();
1182 target_terminal_ours_for_output ();
1184 mi_on_resume_1 (ptid
);
1186 do_cleanups (old_chain
);
1191 mi_solib_loaded (struct so_list
*solib
)
1193 struct switch_thru_all_uis state
;
1195 SWITCH_THRU_ALL_UIS (state
)
1197 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1198 struct ui_out
*uiout
;
1199 struct cleanup
*old_chain
;
1204 uiout
= interp_ui_out (top_level_interpreter ());
1206 old_chain
= make_cleanup_restore_target_terminal ();
1207 target_terminal_ours_for_output ();
1209 fprintf_unfiltered (mi
->event_channel
, "library-loaded");
1211 ui_out_redirect (uiout
, mi
->event_channel
);
1213 ui_out_field_string (uiout
, "id", solib
->so_original_name
);
1214 ui_out_field_string (uiout
, "target-name", solib
->so_original_name
);
1215 ui_out_field_string (uiout
, "host-name", solib
->so_name
);
1216 ui_out_field_int (uiout
, "symbols-loaded", solib
->symbols_loaded
);
1217 if (!gdbarch_has_global_solist (target_gdbarch ()))
1219 ui_out_field_fmt (uiout
, "thread-group", "i%d",
1220 current_inferior ()->num
);
1223 ui_out_redirect (uiout
, NULL
);
1225 gdb_flush (mi
->event_channel
);
1227 do_cleanups (old_chain
);
1232 mi_solib_unloaded (struct so_list
*solib
)
1234 struct switch_thru_all_uis state
;
1236 SWITCH_THRU_ALL_UIS (state
)
1238 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1239 struct ui_out
*uiout
;
1240 struct cleanup
*old_chain
;
1245 uiout
= interp_ui_out (top_level_interpreter ());
1247 old_chain
= make_cleanup_restore_target_terminal ();
1248 target_terminal_ours_for_output ();
1250 fprintf_unfiltered (mi
->event_channel
, "library-unloaded");
1252 ui_out_redirect (uiout
, mi
->event_channel
);
1254 ui_out_field_string (uiout
, "id", solib
->so_original_name
);
1255 ui_out_field_string (uiout
, "target-name", solib
->so_original_name
);
1256 ui_out_field_string (uiout
, "host-name", solib
->so_name
);
1257 if (!gdbarch_has_global_solist (target_gdbarch ()))
1259 ui_out_field_fmt (uiout
, "thread-group", "i%d",
1260 current_inferior ()->num
);
1263 ui_out_redirect (uiout
, NULL
);
1265 gdb_flush (mi
->event_channel
);
1267 do_cleanups (old_chain
);
1271 /* Emit notification about the command parameter change. */
1274 mi_command_param_changed (const char *param
, const char *value
)
1276 struct switch_thru_all_uis state
;
1278 if (mi_suppress_notification
.cmd_param_changed
)
1281 SWITCH_THRU_ALL_UIS (state
)
1283 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1284 struct ui_out
*mi_uiout
;
1285 struct cleanup
*old_chain
;
1290 mi_uiout
= interp_ui_out (top_level_interpreter ());
1292 old_chain
= make_cleanup_restore_target_terminal ();
1293 target_terminal_ours_for_output ();
1295 fprintf_unfiltered (mi
->event_channel
, "cmd-param-changed");
1297 ui_out_redirect (mi_uiout
, mi
->event_channel
);
1299 ui_out_field_string (mi_uiout
, "param", param
);
1300 ui_out_field_string (mi_uiout
, "value", value
);
1302 ui_out_redirect (mi_uiout
, NULL
);
1304 gdb_flush (mi
->event_channel
);
1306 do_cleanups (old_chain
);
1310 /* Emit notification about the target memory change. */
1313 mi_memory_changed (struct inferior
*inferior
, CORE_ADDR memaddr
,
1314 ssize_t len
, const bfd_byte
*myaddr
)
1316 struct switch_thru_all_uis state
;
1318 if (mi_suppress_notification
.memory
)
1321 SWITCH_THRU_ALL_UIS (state
)
1323 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1324 struct ui_out
*mi_uiout
;
1325 struct obj_section
*sec
;
1326 struct cleanup
*old_chain
;
1331 mi_uiout
= interp_ui_out (top_level_interpreter ());
1333 old_chain
= make_cleanup_restore_target_terminal ();
1334 target_terminal_ours_for_output ();
1336 fprintf_unfiltered (mi
->event_channel
, "memory-changed");
1338 ui_out_redirect (mi_uiout
, mi
->event_channel
);
1340 ui_out_field_fmt (mi_uiout
, "thread-group", "i%d", inferior
->num
);
1341 ui_out_field_core_addr (mi_uiout
, "addr", target_gdbarch (), memaddr
);
1342 ui_out_field_fmt (mi_uiout
, "len", "%s", hex_string (len
));
1344 /* Append 'type=code' into notification if MEMADDR falls in the range of
1345 sections contain code. */
1346 sec
= find_pc_section (memaddr
);
1347 if (sec
!= NULL
&& sec
->objfile
!= NULL
)
1349 flagword flags
= bfd_get_section_flags (sec
->objfile
->obfd
,
1350 sec
->the_bfd_section
);
1352 if (flags
& SEC_CODE
)
1353 ui_out_field_string (mi_uiout
, "type", "code");
1356 ui_out_redirect (mi_uiout
, NULL
);
1358 gdb_flush (mi
->event_channel
);
1360 do_cleanups (old_chain
);
1365 report_initial_inferior (struct inferior
*inf
, void *closure
)
1367 /* This function is called from mi_interpreter_init, and since
1368 mi_inferior_added assumes that inferior is fully initialized
1369 and top_level_interpreter_data is set, we cannot call
1371 struct mi_interp
*mi
= (struct mi_interp
*) closure
;
1372 struct cleanup
*old_chain
;
1374 old_chain
= make_cleanup_restore_target_terminal ();
1375 target_terminal_ours_for_output ();
1377 fprintf_unfiltered (mi
->event_channel
,
1378 "thread-group-added,id=\"i%d\"",
1380 gdb_flush (mi
->event_channel
);
1382 do_cleanups (old_chain
);
1386 static struct ui_out
*
1387 mi_ui_out (struct interp
*interp
)
1389 struct mi_interp
*mi
= (struct mi_interp
*) interp_data (interp
);
1391 return mi
->mi_uiout
;
1394 /* Save the original value of raw_stdout here when logging, so we can
1395 restore correctly when done. */
1397 static struct ui_file
*saved_raw_stdout
;
1399 /* Do MI-specific logging actions; save raw_stdout, and change all
1400 the consoles to use the supplied ui-file(s). */
1403 mi_set_logging (struct interp
*interp
, int start_log
,
1404 struct ui_file
*out
, struct ui_file
*logfile
)
1406 struct mi_interp
*mi
= (struct mi_interp
*) interp_data (interp
);
1413 /* The tee created already is based on gdb_stdout, which for MI
1414 is a console and so we end up in an infinite loop of console
1415 writing to ui_file writing to console etc. So discard the
1416 existing tee (it hasn't been used yet, and MI won't ever use
1417 it), and create one based on raw_stdout instead. */
1420 ui_file_delete (out
);
1421 out
= tee_file_new (raw_stdout
, 0, logfile
, 0);
1424 saved_raw_stdout
= raw_stdout
;
1429 raw_stdout
= saved_raw_stdout
;
1430 saved_raw_stdout
= NULL
;
1433 mi_console_set_raw (mi
->out
, raw_stdout
);
1434 mi_console_set_raw (mi
->err
, raw_stdout
);
1435 mi_console_set_raw (mi
->log
, raw_stdout
);
1436 mi_console_set_raw (mi
->targ
, raw_stdout
);
1437 mi_console_set_raw (mi
->event_channel
, raw_stdout
);
1442 /* The MI interpreter's vtable. */
1444 static const struct interp_procs mi_interp_procs
=
1446 mi_interpreter_init
, /* init_proc */
1447 mi_interpreter_resume
, /* resume_proc */
1448 mi_interpreter_suspend
, /* suspend_proc */
1449 mi_interpreter_exec
, /* exec_proc */
1450 mi_ui_out
, /* ui_out_proc */
1451 mi_set_logging
, /* set_logging_proc */
1452 mi_command_loop
/* command_loop_proc */
1455 /* Factory for MI interpreters. */
1457 static struct interp
*
1458 mi_interp_factory (const char *name
)
1460 return interp_new (name
, &mi_interp_procs
, NULL
);
1463 extern initialize_file_ftype _initialize_mi_interp
; /* -Wmissing-prototypes */
1466 _initialize_mi_interp (void)
1468 /* The various interpreter levels. */
1469 interp_factory_register (INTERP_MI1
, mi_interp_factory
);
1470 interp_factory_register (INTERP_MI2
, mi_interp_factory
);
1471 interp_factory_register (INTERP_MI3
, mi_interp_factory
);
1472 interp_factory_register (INTERP_MI
, mi_interp_factory
);
1474 observer_attach_signal_received (mi_on_signal_received
);
1475 observer_attach_end_stepping_range (mi_on_end_stepping_range
);
1476 observer_attach_signal_exited (mi_on_signal_exited
);
1477 observer_attach_exited (mi_on_exited
);
1478 observer_attach_no_history (mi_on_no_history
);
1479 observer_attach_new_thread (mi_new_thread
);
1480 observer_attach_thread_exit (mi_thread_exit
);
1481 observer_attach_inferior_added (mi_inferior_added
);
1482 observer_attach_inferior_appeared (mi_inferior_appeared
);
1483 observer_attach_inferior_exit (mi_inferior_exit
);
1484 observer_attach_inferior_removed (mi_inferior_removed
);
1485 observer_attach_record_changed (mi_record_changed
);
1486 observer_attach_normal_stop (mi_on_normal_stop
);
1487 observer_attach_target_resumed (mi_on_resume
);
1488 observer_attach_solib_loaded (mi_solib_loaded
);
1489 observer_attach_solib_unloaded (mi_solib_unloaded
);
1490 observer_attach_about_to_proceed (mi_about_to_proceed
);
1491 observer_attach_traceframe_changed (mi_traceframe_changed
);
1492 observer_attach_tsv_created (mi_tsv_created
);
1493 observer_attach_tsv_deleted (mi_tsv_deleted
);
1494 observer_attach_tsv_modified (mi_tsv_modified
);
1495 observer_attach_breakpoint_created (mi_breakpoint_created
);
1496 observer_attach_breakpoint_deleted (mi_breakpoint_deleted
);
1497 observer_attach_breakpoint_modified (mi_breakpoint_modified
);
1498 observer_attach_command_param_changed (mi_command_param_changed
);
1499 observer_attach_memory_changed (mi_memory_changed
);
1500 observer_attach_sync_execution_done (mi_on_sync_execution_done
);