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
);
48 /* These are hooks that we put in place while doing interpreter_exec
49 so we can report interesting things that happened "behind the MI's
50 back" in this command. */
52 static int mi_interp_query_hook (const char *ctlstr
, va_list ap
)
53 ATTRIBUTE_PRINTF (1, 0);
55 static void mi_insert_notify_hooks (void);
56 static void mi_remove_notify_hooks (void);
58 static void mi_on_signal_received (enum gdb_signal siggnal
);
59 static void mi_on_end_stepping_range (void);
60 static void mi_on_signal_exited (enum gdb_signal siggnal
);
61 static void mi_on_exited (int exitstatus
);
62 static void mi_on_normal_stop (struct bpstats
*bs
, int print_frame
);
63 static void mi_on_no_history (void);
65 static void mi_new_thread (struct thread_info
*t
);
66 static void mi_thread_exit (struct thread_info
*t
, int silent
);
67 static void mi_record_changed (struct inferior
*, int, const char *,
69 static void mi_inferior_added (struct inferior
*inf
);
70 static void mi_inferior_appeared (struct inferior
*inf
);
71 static void mi_inferior_exit (struct inferior
*inf
);
72 static void mi_inferior_removed (struct inferior
*inf
);
73 static void mi_on_resume (ptid_t ptid
);
74 static void mi_solib_loaded (struct so_list
*solib
);
75 static void mi_solib_unloaded (struct so_list
*solib
);
76 static void mi_about_to_proceed (void);
77 static void mi_traceframe_changed (int tfnum
, int tpnum
);
78 static void mi_tsv_created (const struct trace_state_variable
*tsv
);
79 static void mi_tsv_deleted (const struct trace_state_variable
*tsv
);
80 static void mi_tsv_modified (const struct trace_state_variable
*tsv
);
81 static void mi_breakpoint_created (struct breakpoint
*b
);
82 static void mi_breakpoint_deleted (struct breakpoint
*b
);
83 static void mi_breakpoint_modified (struct breakpoint
*b
);
84 static void mi_command_param_changed (const char *param
, const char *value
);
85 static void mi_memory_changed (struct inferior
*inf
, CORE_ADDR memaddr
,
86 ssize_t len
, const bfd_byte
*myaddr
);
87 static void mi_on_sync_execution_done (void);
89 static int report_initial_inferior (struct inferior
*inf
, void *closure
);
91 /* Display the MI prompt. */
94 display_mi_prompt (struct mi_interp
*mi
)
96 fputs_unfiltered ("(gdb) \n", mi
->raw_stdout
);
97 gdb_flush (mi
->raw_stdout
);
100 /* Returns the INTERP's data cast as mi_interp if INTERP is an MI, and
101 returns NULL otherwise. */
103 static struct mi_interp
*
104 as_mi_interp (struct interp
*interp
)
106 if (ui_out_is_mi_like_p (interp_ui_out (interp
)))
107 return (struct mi_interp
*) interp_data (interp
);
112 mi_interpreter_init (struct interp
*interp
, int top_level
)
114 struct mi_interp
*mi
= XNEW (struct mi_interp
);
118 /* Store the current output channel, so that we can create a console
119 channel that encapsulates and prefixes all gdb_output-type bits
120 coming from the rest of the debugger. */
121 mi
->raw_stdout
= gdb_stdout
;
123 /* Create MI console channels, each with a different prefix so they
124 can be distinguished. */
125 mi
->out
= mi_console_file_new (mi
->raw_stdout
, "~", '"');
126 mi
->err
= mi_console_file_new (mi
->raw_stdout
, "&", '"');
128 mi
->targ
= mi_console_file_new (mi
->raw_stdout
, "@", '"');
129 mi
->event_channel
= mi_console_file_new (mi
->raw_stdout
, "=", 0);
131 name
= interp_name (interp
);
132 /* INTERP_MI selects the most recent released version. "mi2" was
133 released as part of GDB 6.0. */
134 if (strcmp (name
, INTERP_MI
) == 0)
136 else if (strcmp (name
, INTERP_MI1
) == 0)
138 else if (strcmp (name
, INTERP_MI2
) == 0)
140 else if (strcmp (name
, INTERP_MI3
) == 0)
143 gdb_assert_not_reached ("unhandled MI version");
145 mi
->mi_uiout
= mi_out_new (mi_version
);
146 mi
->cli_uiout
= cli_out_new (mi
->out
);
150 /* The initial inferior is created before this function is
151 called, so we need to report it explicitly. Use iteration in
152 case future version of GDB creates more than one inferior
154 iterate_over_inferiors (report_initial_inferior
, mi
);
161 mi_interpreter_resume (void *data
)
163 struct mi_interp
*mi
= (struct mi_interp
*) data
;
164 struct ui
*ui
= current_ui
;
166 /* As per hack note in mi_interpreter_init, swap in the output
168 gdb_setup_readline (0);
170 ui
->call_readline
= gdb_readline_no_editing_callback
;
171 ui
->input_handler
= mi_execute_command_input_handler
;
172 /* FIXME: This is a total hack for now. PB's use of the MI
173 implicitly relies on a bug in the async support which allows
174 asynchronous commands to leak through the commmand loop. The bug
175 involves (but is not limited to) the fact that sync_execution was
176 erroneously initialized to 0. Duplicate by initializing it thus
180 gdb_stdout
= mi
->out
;
181 /* Route error and log output through the MI. */
182 gdb_stderr
= mi
->err
;
183 gdb_stdlog
= mi
->log
;
184 /* Route target output through the MI. */
185 gdb_stdtarg
= mi
->targ
;
186 /* Route target error through the MI as well. */
187 gdb_stdtargerr
= mi
->targ
;
189 /* Replace all the hooks that we know about. There really needs to
190 be a better way of doing this... */
191 clear_interpreter_hooks ();
193 deprecated_show_load_progress
= mi_load_progress
;
199 mi_interpreter_suspend (void *data
)
201 gdb_disable_readline ();
205 static struct gdb_exception
206 mi_interpreter_exec (void *data
, const char *command
)
208 mi_execute_command_wrapper (command
);
209 return exception_none
;
213 mi_cmd_interpreter_exec (char *command
, char **argv
, int argc
)
215 struct interp
*interp_to_use
;
217 char *mi_error_message
= NULL
;
218 struct cleanup
*old_chain
;
221 error (_("-interpreter-exec: "
222 "Usage: -interpreter-exec interp command"));
224 interp_to_use
= interp_lookup (current_ui
, argv
[0]);
225 if (interp_to_use
== NULL
)
226 error (_("-interpreter-exec: could not find interpreter \"%s\""),
229 /* Note that unlike the CLI version of this command, we don't
230 actually set INTERP_TO_USE as the current interpreter, as we
231 still want gdb_stdout, etc. to point at MI streams. */
233 /* Insert the MI out hooks, making sure to also call the
234 interpreter's hooks if it has any. */
235 /* KRS: We shouldn't need this... Events should be installed and
236 they should just ALWAYS fire something out down the MI
238 mi_insert_notify_hooks ();
240 /* Now run the code. */
242 old_chain
= make_cleanup (null_cleanup
, 0);
243 for (i
= 1; i
< argc
; i
++)
245 struct gdb_exception e
= interp_exec (interp_to_use
, argv
[i
]);
249 mi_error_message
= xstrdup (e
.message
);
250 make_cleanup (xfree
, mi_error_message
);
255 mi_remove_notify_hooks ();
257 if (mi_error_message
!= NULL
)
258 error ("%s", mi_error_message
);
259 do_cleanups (old_chain
);
262 /* This inserts a number of hooks that are meant to produce
263 async-notify ("=") MI messages while running commands in another
264 interpreter using mi_interpreter_exec. The canonical use for this
265 is to allow access to the gdb CLI interpreter from within the MI,
266 while still producing MI style output when actions in the CLI
267 command change GDB's state. */
270 mi_insert_notify_hooks (void)
272 deprecated_query_hook
= mi_interp_query_hook
;
276 mi_remove_notify_hooks (void)
278 deprecated_query_hook
= NULL
;
282 mi_interp_query_hook (const char *ctlstr
, va_list ap
)
288 mi_execute_command_wrapper (const char *cmd
)
290 struct ui
*ui
= current_ui
;
292 mi_execute_command (cmd
, stdin
== ui
->instream
);
295 /* Observer for the synchronous_command_done notification. */
298 mi_on_sync_execution_done (void)
300 struct ui
*ui
= current_ui
;
301 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
306 /* If MI is sync, then output the MI prompt now, indicating we're
307 ready for further input. */
309 display_mi_prompt (mi
);
312 /* mi_execute_command_wrapper wrapper suitable for INPUT_HANDLER. */
315 mi_execute_command_input_handler (char *cmd
)
317 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
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
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
;
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 ()))
726 print_stop_event (mi
->cli_uiout
);
728 tp
= inferior_thread ();
729 ui_out_field_int (mi_uiout
, "thread-id", tp
->global_num
);
732 struct cleanup
*back_to
= make_cleanup_ui_out_list_begin_end
733 (mi_uiout
, "stopped-threads");
735 ui_out_field_int (mi_uiout
, NULL
, tp
->global_num
);
736 do_cleanups (back_to
);
739 ui_out_field_string (mi_uiout
, "stopped-threads", "all");
741 core
= target_core_of_thread (inferior_ptid
);
743 ui_out_field_int (mi_uiout
, "core", core
);
746 fputs_unfiltered ("*stopped", mi
->raw_stdout
);
747 mi_out_put (mi_uiout
, mi
->raw_stdout
);
748 mi_out_rewind (mi_uiout
);
749 mi_print_timing_maybe (mi
->raw_stdout
);
750 fputs_unfiltered ("\n", mi
->raw_stdout
);
751 gdb_flush (mi
->raw_stdout
);
755 mi_on_normal_stop (struct bpstats
*bs
, int print_frame
)
757 struct switch_thru_all_uis state
;
759 SWITCH_THRU_ALL_UIS (state
)
761 if (as_mi_interp (top_level_interpreter ()) == NULL
)
764 mi_on_normal_stop_1 (bs
, print_frame
);
769 mi_about_to_proceed (void)
771 /* Suppress output while calling an inferior function. */
773 if (!ptid_equal (inferior_ptid
, null_ptid
))
775 struct thread_info
*tp
= inferior_thread ();
777 if (tp
->control
.in_infcall
)
784 /* When the element is non-zero, no MI notifications will be emitted in
785 response to the corresponding observers. */
787 struct mi_suppress_notification mi_suppress_notification
=
794 /* Emit notification on changing a traceframe. */
797 mi_traceframe_changed (int tfnum
, int tpnum
)
799 struct switch_thru_all_uis state
;
801 if (mi_suppress_notification
.traceframe
)
804 SWITCH_THRU_ALL_UIS (state
)
806 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
807 struct cleanup
*old_chain
;
812 old_chain
= make_cleanup_restore_target_terminal ();
813 target_terminal_ours_for_output ();
816 fprintf_unfiltered (mi
->event_channel
, "traceframe-changed,"
817 "num=\"%d\",tracepoint=\"%d\"\n",
820 fprintf_unfiltered (mi
->event_channel
, "traceframe-changed,end");
822 gdb_flush (mi
->event_channel
);
824 do_cleanups (old_chain
);
828 /* Emit notification on creating a trace state variable. */
831 mi_tsv_created (const struct trace_state_variable
*tsv
)
833 struct switch_thru_all_uis state
;
835 SWITCH_THRU_ALL_UIS (state
)
837 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
838 struct cleanup
*old_chain
;
843 old_chain
= make_cleanup_restore_target_terminal ();
844 target_terminal_ours_for_output ();
846 fprintf_unfiltered (mi
->event_channel
, "tsv-created,"
847 "name=\"%s\",initial=\"%s\"\n",
848 tsv
->name
, plongest (tsv
->initial_value
));
850 gdb_flush (mi
->event_channel
);
852 do_cleanups (old_chain
);
856 /* Emit notification on deleting a trace state variable. */
859 mi_tsv_deleted (const struct trace_state_variable
*tsv
)
861 struct switch_thru_all_uis state
;
863 SWITCH_THRU_ALL_UIS (state
)
865 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
866 struct cleanup
*old_chain
;
871 old_chain
= make_cleanup_restore_target_terminal ();
872 target_terminal_ours_for_output ();
875 fprintf_unfiltered (mi
->event_channel
, "tsv-deleted,"
876 "name=\"%s\"\n", tsv
->name
);
878 fprintf_unfiltered (mi
->event_channel
, "tsv-deleted\n");
880 gdb_flush (mi
->event_channel
);
882 do_cleanups (old_chain
);
886 /* Emit notification on modifying a trace state variable. */
889 mi_tsv_modified (const struct trace_state_variable
*tsv
)
891 struct switch_thru_all_uis state
;
893 SWITCH_THRU_ALL_UIS (state
)
895 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
896 struct ui_out
*mi_uiout
;
897 struct cleanup
*old_chain
;
902 mi_uiout
= interp_ui_out (top_level_interpreter ());
904 old_chain
= make_cleanup_restore_target_terminal ();
905 target_terminal_ours_for_output ();
907 fprintf_unfiltered (mi
->event_channel
,
910 ui_out_redirect (mi_uiout
, mi
->event_channel
);
912 ui_out_field_string (mi_uiout
, "name", tsv
->name
);
913 ui_out_field_string (mi_uiout
, "initial",
914 plongest (tsv
->initial_value
));
915 if (tsv
->value_known
)
916 ui_out_field_string (mi_uiout
, "current", plongest (tsv
->value
));
918 ui_out_redirect (mi_uiout
, NULL
);
920 gdb_flush (mi
->event_channel
);
922 do_cleanups (old_chain
);
926 /* Emit notification about a created breakpoint. */
929 mi_breakpoint_created (struct breakpoint
*b
)
931 struct switch_thru_all_uis state
;
933 if (mi_suppress_notification
.breakpoint
)
939 SWITCH_THRU_ALL_UIS (state
)
941 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
942 struct ui_out
*mi_uiout
;
943 struct cleanup
*old_chain
;
948 mi_uiout
= interp_ui_out (top_level_interpreter ());
950 old_chain
= make_cleanup_restore_target_terminal ();
951 target_terminal_ours_for_output ();
953 fprintf_unfiltered (mi
->event_channel
,
954 "breakpoint-created");
955 /* We want the output from gdb_breakpoint_query to go to
956 mi->event_channel. One approach would be to just call
957 gdb_breakpoint_query, and then use mi_out_put to send the current
958 content of mi_outout into mi->event_channel. However, that will
959 break if anything is output to mi_uiout prior to calling the
960 breakpoint_created notifications. So, we use
962 ui_out_redirect (mi_uiout
, mi
->event_channel
);
965 gdb_breakpoint_query (mi_uiout
, b
->number
, NULL
);
967 CATCH (e
, RETURN_MASK_ERROR
)
972 ui_out_redirect (mi_uiout
, NULL
);
974 gdb_flush (mi
->event_channel
);
976 do_cleanups (old_chain
);
980 /* Emit notification about deleted breakpoint. */
983 mi_breakpoint_deleted (struct breakpoint
*b
)
985 struct switch_thru_all_uis state
;
987 if (mi_suppress_notification
.breakpoint
)
993 SWITCH_THRU_ALL_UIS (state
)
995 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
996 struct cleanup
*old_chain
;
1001 old_chain
= make_cleanup_restore_target_terminal ();
1002 target_terminal_ours_for_output ();
1004 fprintf_unfiltered (mi
->event_channel
, "breakpoint-deleted,id=\"%d\"",
1007 gdb_flush (mi
->event_channel
);
1009 do_cleanups (old_chain
);
1013 /* Emit notification about modified breakpoint. */
1016 mi_breakpoint_modified (struct breakpoint
*b
)
1018 struct switch_thru_all_uis state
;
1020 if (mi_suppress_notification
.breakpoint
)
1026 SWITCH_THRU_ALL_UIS (state
)
1028 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1029 struct cleanup
*old_chain
;
1034 old_chain
= make_cleanup_restore_target_terminal ();
1035 target_terminal_ours_for_output ();
1036 fprintf_unfiltered (mi
->event_channel
,
1037 "breakpoint-modified");
1038 /* We want the output from gdb_breakpoint_query to go to
1039 mi->event_channel. One approach would be to just call
1040 gdb_breakpoint_query, and then use mi_out_put to send the current
1041 content of mi_outout into mi->event_channel. However, that will
1042 break if anything is output to mi_uiout prior to calling the
1043 breakpoint_created notifications. So, we use
1045 ui_out_redirect (mi
->mi_uiout
, mi
->event_channel
);
1048 gdb_breakpoint_query (mi
->mi_uiout
, b
->number
, NULL
);
1050 CATCH (e
, RETURN_MASK_ERROR
)
1055 ui_out_redirect (mi
->mi_uiout
, NULL
);
1057 gdb_flush (mi
->event_channel
);
1059 do_cleanups (old_chain
);
1064 mi_output_running_pid (struct thread_info
*info
, void *arg
)
1066 ptid_t
*ptid
= (ptid_t
*) arg
;
1067 struct switch_thru_all_uis state
;
1069 SWITCH_THRU_ALL_UIS (state
)
1071 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1076 if (ptid_get_pid (*ptid
) == ptid_get_pid (info
->ptid
))
1077 fprintf_unfiltered (mi
->raw_stdout
,
1078 "*running,thread-id=\"%d\"\n",
1086 mi_inferior_count (struct inferior
*inf
, void *arg
)
1090 int *count_p
= (int *) arg
;
1098 mi_on_resume_1 (struct mi_interp
*mi
, ptid_t ptid
)
1100 /* To cater for older frontends, emit ^running, but do it only once
1101 per each command. We do it here, since at this point we know
1102 that the target was successfully resumed, and in non-async mode,
1103 we won't return back to MI interpreter code until the target
1104 is done running, so delaying the output of "^running" until then
1105 will make it impossible for frontend to know what's going on.
1107 In future (MI3), we'll be outputting "^done" here. */
1108 if (!running_result_record_printed
&& mi_proceeded
)
1110 fprintf_unfiltered (mi
->raw_stdout
, "%s^running\n",
1111 current_token
? current_token
: "");
1114 if (ptid_get_pid (ptid
) == -1)
1115 fprintf_unfiltered (mi
->raw_stdout
, "*running,thread-id=\"all\"\n");
1116 else if (ptid_is_pid (ptid
))
1120 /* Backwards compatibility. If there's only one inferior,
1121 output "all", otherwise, output each resumed thread
1123 iterate_over_inferiors (mi_inferior_count
, &count
);
1126 fprintf_unfiltered (mi
->raw_stdout
, "*running,thread-id=\"all\"\n");
1128 iterate_over_threads (mi_output_running_pid
, &ptid
);
1132 struct thread_info
*ti
= find_thread_ptid (ptid
);
1135 fprintf_unfiltered (mi
->raw_stdout
, "*running,thread-id=\"%d\"\n",
1139 if (!running_result_record_printed
&& mi_proceeded
)
1141 running_result_record_printed
= 1;
1142 /* This is what gdb used to do historically -- printing prompt even if
1143 it cannot actually accept any input. This will be surely removed
1144 for MI3, and may be removed even earlier. SYNC_EXECUTION is
1145 checked here because we only need to emit a prompt if a
1146 synchronous command was issued when the target is async. */
1147 if (!target_can_async_p () || sync_execution
)
1148 fputs_unfiltered ("(gdb) \n", mi
->raw_stdout
);
1150 gdb_flush (mi
->raw_stdout
);
1154 mi_on_resume (ptid_t ptid
)
1156 struct thread_info
*tp
= NULL
;
1157 struct switch_thru_all_uis state
;
1159 if (ptid_equal (ptid
, minus_one_ptid
) || ptid_is_pid (ptid
))
1160 tp
= inferior_thread ();
1162 tp
= find_thread_ptid (ptid
);
1164 /* Suppress output while calling an inferior function. */
1165 if (tp
->control
.in_infcall
)
1168 SWITCH_THRU_ALL_UIS (state
)
1170 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1171 struct cleanup
*old_chain
;
1176 old_chain
= make_cleanup_restore_target_terminal ();
1177 target_terminal_ours_for_output ();
1179 mi_on_resume_1 (mi
, ptid
);
1181 do_cleanups (old_chain
);
1186 mi_solib_loaded (struct so_list
*solib
)
1188 struct switch_thru_all_uis state
;
1190 SWITCH_THRU_ALL_UIS (state
)
1192 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1193 struct ui_out
*uiout
;
1194 struct cleanup
*old_chain
;
1199 uiout
= interp_ui_out (top_level_interpreter ());
1201 old_chain
= make_cleanup_restore_target_terminal ();
1202 target_terminal_ours_for_output ();
1204 fprintf_unfiltered (mi
->event_channel
, "library-loaded");
1206 ui_out_redirect (uiout
, mi
->event_channel
);
1208 ui_out_field_string (uiout
, "id", solib
->so_original_name
);
1209 ui_out_field_string (uiout
, "target-name", solib
->so_original_name
);
1210 ui_out_field_string (uiout
, "host-name", solib
->so_name
);
1211 ui_out_field_int (uiout
, "symbols-loaded", solib
->symbols_loaded
);
1212 if (!gdbarch_has_global_solist (target_gdbarch ()))
1214 ui_out_field_fmt (uiout
, "thread-group", "i%d",
1215 current_inferior ()->num
);
1218 ui_out_redirect (uiout
, NULL
);
1220 gdb_flush (mi
->event_channel
);
1222 do_cleanups (old_chain
);
1227 mi_solib_unloaded (struct so_list
*solib
)
1229 struct switch_thru_all_uis state
;
1231 SWITCH_THRU_ALL_UIS (state
)
1233 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1234 struct ui_out
*uiout
;
1235 struct cleanup
*old_chain
;
1240 uiout
= interp_ui_out (top_level_interpreter ());
1242 old_chain
= make_cleanup_restore_target_terminal ();
1243 target_terminal_ours_for_output ();
1245 fprintf_unfiltered (mi
->event_channel
, "library-unloaded");
1247 ui_out_redirect (uiout
, mi
->event_channel
);
1249 ui_out_field_string (uiout
, "id", solib
->so_original_name
);
1250 ui_out_field_string (uiout
, "target-name", solib
->so_original_name
);
1251 ui_out_field_string (uiout
, "host-name", solib
->so_name
);
1252 if (!gdbarch_has_global_solist (target_gdbarch ()))
1254 ui_out_field_fmt (uiout
, "thread-group", "i%d",
1255 current_inferior ()->num
);
1258 ui_out_redirect (uiout
, NULL
);
1260 gdb_flush (mi
->event_channel
);
1262 do_cleanups (old_chain
);
1266 /* Emit notification about the command parameter change. */
1269 mi_command_param_changed (const char *param
, const char *value
)
1271 struct switch_thru_all_uis state
;
1273 if (mi_suppress_notification
.cmd_param_changed
)
1276 SWITCH_THRU_ALL_UIS (state
)
1278 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1279 struct ui_out
*mi_uiout
;
1280 struct cleanup
*old_chain
;
1285 mi_uiout
= interp_ui_out (top_level_interpreter ());
1287 old_chain
= make_cleanup_restore_target_terminal ();
1288 target_terminal_ours_for_output ();
1290 fprintf_unfiltered (mi
->event_channel
, "cmd-param-changed");
1292 ui_out_redirect (mi_uiout
, mi
->event_channel
);
1294 ui_out_field_string (mi_uiout
, "param", param
);
1295 ui_out_field_string (mi_uiout
, "value", value
);
1297 ui_out_redirect (mi_uiout
, NULL
);
1299 gdb_flush (mi
->event_channel
);
1301 do_cleanups (old_chain
);
1305 /* Emit notification about the target memory change. */
1308 mi_memory_changed (struct inferior
*inferior
, CORE_ADDR memaddr
,
1309 ssize_t len
, const bfd_byte
*myaddr
)
1311 struct switch_thru_all_uis state
;
1313 if (mi_suppress_notification
.memory
)
1316 SWITCH_THRU_ALL_UIS (state
)
1318 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1319 struct ui_out
*mi_uiout
;
1320 struct obj_section
*sec
;
1321 struct cleanup
*old_chain
;
1326 mi_uiout
= interp_ui_out (top_level_interpreter ());
1328 old_chain
= make_cleanup_restore_target_terminal ();
1329 target_terminal_ours_for_output ();
1331 fprintf_unfiltered (mi
->event_channel
, "memory-changed");
1333 ui_out_redirect (mi_uiout
, mi
->event_channel
);
1335 ui_out_field_fmt (mi_uiout
, "thread-group", "i%d", inferior
->num
);
1336 ui_out_field_core_addr (mi_uiout
, "addr", target_gdbarch (), memaddr
);
1337 ui_out_field_fmt (mi_uiout
, "len", "%s", hex_string (len
));
1339 /* Append 'type=code' into notification if MEMADDR falls in the range of
1340 sections contain code. */
1341 sec
= find_pc_section (memaddr
);
1342 if (sec
!= NULL
&& sec
->objfile
!= NULL
)
1344 flagword flags
= bfd_get_section_flags (sec
->objfile
->obfd
,
1345 sec
->the_bfd_section
);
1347 if (flags
& SEC_CODE
)
1348 ui_out_field_string (mi_uiout
, "type", "code");
1351 ui_out_redirect (mi_uiout
, NULL
);
1353 gdb_flush (mi
->event_channel
);
1355 do_cleanups (old_chain
);
1360 report_initial_inferior (struct inferior
*inf
, void *closure
)
1362 /* This function is called from mi_interpreter_init, and since
1363 mi_inferior_added assumes that inferior is fully initialized
1364 and top_level_interpreter_data is set, we cannot call
1366 struct mi_interp
*mi
= (struct mi_interp
*) closure
;
1367 struct cleanup
*old_chain
;
1369 old_chain
= make_cleanup_restore_target_terminal ();
1370 target_terminal_ours_for_output ();
1372 fprintf_unfiltered (mi
->event_channel
,
1373 "thread-group-added,id=\"i%d\"",
1375 gdb_flush (mi
->event_channel
);
1377 do_cleanups (old_chain
);
1381 static struct ui_out
*
1382 mi_ui_out (struct interp
*interp
)
1384 struct mi_interp
*mi
= (struct mi_interp
*) interp_data (interp
);
1386 return mi
->mi_uiout
;
1389 /* Do MI-specific logging actions; save raw_stdout, and change all
1390 the consoles to use the supplied ui-file(s). */
1393 mi_set_logging (struct interp
*interp
, int start_log
,
1394 struct ui_file
*out
, struct ui_file
*logfile
)
1396 struct mi_interp
*mi
= (struct mi_interp
*) interp_data (interp
);
1403 /* The tee created already is based on gdb_stdout, which for MI
1404 is a console and so we end up in an infinite loop of console
1405 writing to ui_file writing to console etc. So discard the
1406 existing tee (it hasn't been used yet, and MI won't ever use
1407 it), and create one based on raw_stdout instead. */
1410 ui_file_delete (out
);
1411 out
= tee_file_new (mi
->raw_stdout
, 0, logfile
, 0);
1414 mi
->saved_raw_stdout
= mi
->raw_stdout
;
1415 mi
->raw_stdout
= out
;
1419 mi
->raw_stdout
= mi
->saved_raw_stdout
;
1420 mi
->saved_raw_stdout
= NULL
;
1423 mi_console_set_raw (mi
->out
, mi
->raw_stdout
);
1424 mi_console_set_raw (mi
->err
, mi
->raw_stdout
);
1425 mi_console_set_raw (mi
->log
, mi
->raw_stdout
);
1426 mi_console_set_raw (mi
->targ
, mi
->raw_stdout
);
1427 mi_console_set_raw (mi
->event_channel
, mi
->raw_stdout
);
1432 /* The MI interpreter's vtable. */
1434 static const struct interp_procs mi_interp_procs
=
1436 mi_interpreter_init
, /* init_proc */
1437 mi_interpreter_resume
, /* resume_proc */
1438 mi_interpreter_suspend
, /* suspend_proc */
1439 mi_interpreter_exec
, /* exec_proc */
1440 mi_ui_out
, /* ui_out_proc */
1441 mi_set_logging
, /* set_logging_proc */
1442 mi_interpreter_pre_command_loop
/* pre_command_loop_proc */
1445 /* Factory for MI interpreters. */
1447 static struct interp
*
1448 mi_interp_factory (const char *name
)
1450 return interp_new (name
, &mi_interp_procs
, NULL
);
1453 extern initialize_file_ftype _initialize_mi_interp
; /* -Wmissing-prototypes */
1456 _initialize_mi_interp (void)
1458 /* The various interpreter levels. */
1459 interp_factory_register (INTERP_MI1
, mi_interp_factory
);
1460 interp_factory_register (INTERP_MI2
, mi_interp_factory
);
1461 interp_factory_register (INTERP_MI3
, mi_interp_factory
);
1462 interp_factory_register (INTERP_MI
, mi_interp_factory
);
1464 observer_attach_signal_received (mi_on_signal_received
);
1465 observer_attach_end_stepping_range (mi_on_end_stepping_range
);
1466 observer_attach_signal_exited (mi_on_signal_exited
);
1467 observer_attach_exited (mi_on_exited
);
1468 observer_attach_no_history (mi_on_no_history
);
1469 observer_attach_new_thread (mi_new_thread
);
1470 observer_attach_thread_exit (mi_thread_exit
);
1471 observer_attach_inferior_added (mi_inferior_added
);
1472 observer_attach_inferior_appeared (mi_inferior_appeared
);
1473 observer_attach_inferior_exit (mi_inferior_exit
);
1474 observer_attach_inferior_removed (mi_inferior_removed
);
1475 observer_attach_record_changed (mi_record_changed
);
1476 observer_attach_normal_stop (mi_on_normal_stop
);
1477 observer_attach_target_resumed (mi_on_resume
);
1478 observer_attach_solib_loaded (mi_solib_loaded
);
1479 observer_attach_solib_unloaded (mi_solib_unloaded
);
1480 observer_attach_about_to_proceed (mi_about_to_proceed
);
1481 observer_attach_traceframe_changed (mi_traceframe_changed
);
1482 observer_attach_tsv_created (mi_tsv_created
);
1483 observer_attach_tsv_deleted (mi_tsv_deleted
);
1484 observer_attach_tsv_modified (mi_tsv_modified
);
1485 observer_attach_breakpoint_created (mi_breakpoint_created
);
1486 observer_attach_breakpoint_deleted (mi_breakpoint_deleted
);
1487 observer_attach_breakpoint_modified (mi_breakpoint_modified
);
1488 observer_attach_command_param_changed (mi_command_param_changed
);
1489 observer_attach_memory_changed (mi_memory_changed
);
1490 observer_attach_sync_execution_done (mi_on_sync_execution_done
);