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 /* Returns the INTERP's data cast as mi_interp if INTERP is an MI, and
93 returns NULL otherwise. */
95 static struct mi_interp
*
96 as_mi_interp (struct interp
*interp
)
98 if (ui_out_is_mi_like_p (interp_ui_out (interp
)))
99 return (struct mi_interp
*) interp_data (interp
);
104 mi_interpreter_init (struct interp
*interp
, int top_level
)
106 struct mi_interp
*mi
= XNEW (struct mi_interp
);
110 /* Assign the output channel created at startup to its own global,
111 so that we can create a console channel that encapsulates and
112 prefixes all gdb_output-type bits coming from the rest of the
115 raw_stdout
= gdb_stdout
;
117 /* Create MI console channels, each with a different prefix so they
118 can be distinguished. */
119 mi
->out
= mi_console_file_new (raw_stdout
, "~", '"');
120 mi
->err
= mi_console_file_new (raw_stdout
, "&", '"');
122 mi
->targ
= mi_console_file_new (raw_stdout
, "@", '"');
123 mi
->event_channel
= mi_console_file_new (raw_stdout
, "=", 0);
125 name
= interp_name (interp
);
126 /* INTERP_MI selects the most recent released version. "mi2" was
127 released as part of GDB 6.0. */
128 if (strcmp (name
, INTERP_MI
) == 0)
130 else if (strcmp (name
, INTERP_MI1
) == 0)
132 else if (strcmp (name
, INTERP_MI2
) == 0)
134 else if (strcmp (name
, INTERP_MI3
) == 0)
137 gdb_assert_not_reached ("unhandled MI version");
139 mi
->mi_uiout
= mi_out_new (mi_version
);
140 mi
->cli_uiout
= cli_out_new (mi
->out
);
144 /* The initial inferior is created before this function is
145 called, so we need to report it explicitly. Use iteration in
146 case future version of GDB creates more than one inferior
148 iterate_over_inferiors (report_initial_inferior
, mi
);
155 mi_interpreter_resume (void *data
)
157 struct mi_interp
*mi
= (struct mi_interp
*) data
;
158 struct ui
*ui
= current_ui
;
160 /* As per hack note in mi_interpreter_init, swap in the output
162 gdb_setup_readline ();
164 /* These overwrite some of the initialization done in
165 _intialize_event_loop. */
166 ui
->call_readline
= gdb_readline_no_editing_callback
;
167 ui
->input_handler
= mi_execute_command_input_handler
;
168 async_command_editing_p
= 0;
169 /* FIXME: This is a total hack for now. PB's use of the MI
170 implicitly relies on a bug in the async support which allows
171 asynchronous commands to leak through the commmand loop. The bug
172 involves (but is not limited to) the fact that sync_execution was
173 erroneously initialized to 0. Duplicate by initializing it thus
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 mi_execute_command (cmd
, stdin
== instream
);
290 /* Observer for the synchronous_command_done notification. */
293 mi_on_sync_execution_done (void)
295 struct ui
*ui
= current_ui
;
296 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
301 /* If MI is sync, then output the MI prompt now, indicating we're
302 ready for further input. */
305 fputs_unfiltered ("(gdb) \n", raw_stdout
);
306 gdb_flush (raw_stdout
);
310 /* mi_execute_command_wrapper wrapper suitable for INPUT_HANDLER. */
313 mi_execute_command_input_handler (char *cmd
)
315 mi_execute_command_wrapper (cmd
);
317 /* Print a prompt, indicating we're ready for further input, unless
318 we just started a synchronous command. In that case, we're about
319 to go back to the event loop and will output the prompt in the
320 'synchronous_command_done' observer when the target next
324 fputs_unfiltered ("(gdb) \n", raw_stdout
);
325 gdb_flush (raw_stdout
);
330 mi_command_loop (void *data
)
332 /* Turn off 8 bit strings in quoted output. Any character with the
333 high bit set is printed using C's octal format. */
334 sevenbit_strings
= 1;
336 /* Tell the world that we're alive. */
337 fputs_unfiltered ("(gdb) \n", raw_stdout
);
338 gdb_flush (raw_stdout
);
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 ());
687 struct thread_info
*tp
;
690 tp
= inferior_thread ();
692 if (tp
->thread_fsm
!= NULL
693 && thread_fsm_finished_p (tp
->thread_fsm
))
695 enum async_reply_reason reason
;
697 reason
= thread_fsm_async_reply_reason (tp
->thread_fsm
);
698 ui_out_field_string (mi_uiout
, "reason",
699 async_reason_lookup (reason
));
701 print_stop_event (mi_uiout
);
703 /* Breakpoint hits should always be mirrored to the console.
704 Deciding what to mirror to the console wrt to breakpoints and
705 random stops gets messy real fast. E.g., say "s" trips on a
706 breakpoint. We'd clearly want to mirror the event to the
707 console in this case. But what about more complicated cases
708 like "s&; thread n; s&", and one of those steps spawning a
709 new thread, and that thread hitting a breakpoint? It's
710 impossible in general to track whether the thread had any
711 relation to the commands that had been executed. So we just
712 simplify and always mirror breakpoints and random events to
715 OTOH, we should print the source line to the console when
716 stepping or other similar commands, iff the step was started
717 by a console command, but not if it was started with
718 -exec-step or similar. */
719 if ((bpstat_what (tp
->control
.stop_bpstat
).main_action
720 == BPSTAT_WHAT_STOP_NOISY
)
721 || !(tp
->thread_fsm
!= NULL
722 && thread_fsm_finished_p (tp
->thread_fsm
))
723 || (tp
->control
.command_interp
!= NULL
724 && tp
->control
.command_interp
!= top_level_interpreter ()))
727 = (struct mi_interp
*) top_level_interpreter_data ();
729 print_stop_event (mi
->cli_uiout
);
732 tp
= inferior_thread ();
733 ui_out_field_int (mi_uiout
, "thread-id", tp
->global_num
);
736 struct cleanup
*back_to
= make_cleanup_ui_out_list_begin_end
737 (mi_uiout
, "stopped-threads");
739 ui_out_field_int (mi_uiout
, NULL
, tp
->global_num
);
740 do_cleanups (back_to
);
743 ui_out_field_string (mi_uiout
, "stopped-threads", "all");
745 core
= target_core_of_thread (inferior_ptid
);
747 ui_out_field_int (mi_uiout
, "core", core
);
750 fputs_unfiltered ("*stopped", raw_stdout
);
751 mi_out_put (mi_uiout
, raw_stdout
);
752 mi_out_rewind (mi_uiout
);
753 mi_print_timing_maybe ();
754 fputs_unfiltered ("\n", raw_stdout
);
755 gdb_flush (raw_stdout
);
759 mi_on_normal_stop (struct bpstats
*bs
, int print_frame
)
761 struct switch_thru_all_uis state
;
763 SWITCH_THRU_ALL_UIS (state
)
765 if (as_mi_interp (top_level_interpreter ()) == NULL
)
768 mi_on_normal_stop_1 (bs
, print_frame
);
773 mi_about_to_proceed (void)
775 /* Suppress output while calling an inferior function. */
777 if (!ptid_equal (inferior_ptid
, null_ptid
))
779 struct thread_info
*tp
= inferior_thread ();
781 if (tp
->control
.in_infcall
)
788 /* When the element is non-zero, no MI notifications will be emitted in
789 response to the corresponding observers. */
791 struct mi_suppress_notification mi_suppress_notification
=
798 /* Emit notification on changing a traceframe. */
801 mi_traceframe_changed (int tfnum
, int tpnum
)
803 struct switch_thru_all_uis state
;
805 if (mi_suppress_notification
.traceframe
)
808 SWITCH_THRU_ALL_UIS (state
)
810 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
811 struct cleanup
*old_chain
;
816 old_chain
= make_cleanup_restore_target_terminal ();
817 target_terminal_ours_for_output ();
820 fprintf_unfiltered (mi
->event_channel
, "traceframe-changed,"
821 "num=\"%d\",tracepoint=\"%d\"\n",
824 fprintf_unfiltered (mi
->event_channel
, "traceframe-changed,end");
826 gdb_flush (mi
->event_channel
);
828 do_cleanups (old_chain
);
832 /* Emit notification on creating a trace state variable. */
835 mi_tsv_created (const struct trace_state_variable
*tsv
)
837 struct switch_thru_all_uis state
;
839 SWITCH_THRU_ALL_UIS (state
)
841 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
842 struct cleanup
*old_chain
;
847 old_chain
= make_cleanup_restore_target_terminal ();
848 target_terminal_ours_for_output ();
850 fprintf_unfiltered (mi
->event_channel
, "tsv-created,"
851 "name=\"%s\",initial=\"%s\"\n",
852 tsv
->name
, plongest (tsv
->initial_value
));
854 gdb_flush (mi
->event_channel
);
856 do_cleanups (old_chain
);
860 /* Emit notification on deleting a trace state variable. */
863 mi_tsv_deleted (const struct trace_state_variable
*tsv
)
865 struct switch_thru_all_uis state
;
867 SWITCH_THRU_ALL_UIS (state
)
869 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
870 struct cleanup
*old_chain
;
875 old_chain
= make_cleanup_restore_target_terminal ();
876 target_terminal_ours_for_output ();
879 fprintf_unfiltered (mi
->event_channel
, "tsv-deleted,"
880 "name=\"%s\"\n", tsv
->name
);
882 fprintf_unfiltered (mi
->event_channel
, "tsv-deleted\n");
884 gdb_flush (mi
->event_channel
);
886 do_cleanups (old_chain
);
890 /* Emit notification on modifying a trace state variable. */
893 mi_tsv_modified (const struct trace_state_variable
*tsv
)
895 struct switch_thru_all_uis state
;
897 SWITCH_THRU_ALL_UIS (state
)
899 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
900 struct ui_out
*mi_uiout
;
901 struct cleanup
*old_chain
;
906 mi_uiout
= interp_ui_out (top_level_interpreter ());
908 old_chain
= make_cleanup_restore_target_terminal ();
909 target_terminal_ours_for_output ();
911 fprintf_unfiltered (mi
->event_channel
,
914 ui_out_redirect (mi_uiout
, mi
->event_channel
);
916 ui_out_field_string (mi_uiout
, "name", tsv
->name
);
917 ui_out_field_string (mi_uiout
, "initial",
918 plongest (tsv
->initial_value
));
919 if (tsv
->value_known
)
920 ui_out_field_string (mi_uiout
, "current", plongest (tsv
->value
));
922 ui_out_redirect (mi_uiout
, NULL
);
924 gdb_flush (mi
->event_channel
);
926 do_cleanups (old_chain
);
930 /* Emit notification about a created breakpoint. */
933 mi_breakpoint_created (struct breakpoint
*b
)
935 struct switch_thru_all_uis state
;
937 if (mi_suppress_notification
.breakpoint
)
943 SWITCH_THRU_ALL_UIS (state
)
945 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
946 struct ui_out
*mi_uiout
;
947 struct cleanup
*old_chain
;
952 mi_uiout
= interp_ui_out (top_level_interpreter ());
954 old_chain
= make_cleanup_restore_target_terminal ();
955 target_terminal_ours_for_output ();
957 fprintf_unfiltered (mi
->event_channel
,
958 "breakpoint-created");
959 /* We want the output from gdb_breakpoint_query to go to
960 mi->event_channel. One approach would be to just call
961 gdb_breakpoint_query, and then use mi_out_put to send the current
962 content of mi_outout into mi->event_channel. However, that will
963 break if anything is output to mi_uiout prior to calling the
964 breakpoint_created notifications. So, we use
966 ui_out_redirect (mi_uiout
, mi
->event_channel
);
969 gdb_breakpoint_query (mi_uiout
, b
->number
, NULL
);
971 CATCH (e
, RETURN_MASK_ERROR
)
976 ui_out_redirect (mi_uiout
, NULL
);
978 gdb_flush (mi
->event_channel
);
980 do_cleanups (old_chain
);
984 /* Emit notification about deleted breakpoint. */
987 mi_breakpoint_deleted (struct breakpoint
*b
)
989 struct switch_thru_all_uis state
;
991 if (mi_suppress_notification
.breakpoint
)
997 SWITCH_THRU_ALL_UIS (state
)
999 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1000 struct cleanup
*old_chain
;
1005 old_chain
= make_cleanup_restore_target_terminal ();
1006 target_terminal_ours_for_output ();
1008 fprintf_unfiltered (mi
->event_channel
, "breakpoint-deleted,id=\"%d\"",
1011 gdb_flush (mi
->event_channel
);
1013 do_cleanups (old_chain
);
1017 /* Emit notification about modified breakpoint. */
1020 mi_breakpoint_modified (struct breakpoint
*b
)
1022 struct switch_thru_all_uis state
;
1024 if (mi_suppress_notification
.breakpoint
)
1030 SWITCH_THRU_ALL_UIS (state
)
1032 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1033 struct cleanup
*old_chain
;
1038 old_chain
= make_cleanup_restore_target_terminal ();
1039 target_terminal_ours_for_output ();
1040 fprintf_unfiltered (mi
->event_channel
,
1041 "breakpoint-modified");
1042 /* We want the output from gdb_breakpoint_query to go to
1043 mi->event_channel. One approach would be to just call
1044 gdb_breakpoint_query, and then use mi_out_put to send the current
1045 content of mi_outout into mi->event_channel. However, that will
1046 break if anything is output to mi_uiout prior to calling the
1047 breakpoint_created notifications. So, we use
1049 ui_out_redirect (mi
->mi_uiout
, mi
->event_channel
);
1052 gdb_breakpoint_query (mi
->mi_uiout
, b
->number
, NULL
);
1054 CATCH (e
, RETURN_MASK_ERROR
)
1059 ui_out_redirect (mi
->mi_uiout
, NULL
);
1061 gdb_flush (mi
->event_channel
);
1063 do_cleanups (old_chain
);
1068 mi_output_running_pid (struct thread_info
*info
, void *arg
)
1070 ptid_t
*ptid
= (ptid_t
*) arg
;
1071 struct switch_thru_all_uis state
;
1073 SWITCH_THRU_ALL_UIS (state
)
1075 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1080 if (ptid_get_pid (*ptid
) == ptid_get_pid (info
->ptid
))
1081 fprintf_unfiltered (raw_stdout
,
1082 "*running,thread-id=\"%d\"\n",
1090 mi_inferior_count (struct inferior
*inf
, void *arg
)
1094 int *count_p
= (int *) arg
;
1102 mi_on_resume_1 (ptid_t ptid
)
1104 /* To cater for older frontends, emit ^running, but do it only once
1105 per each command. We do it here, since at this point we know
1106 that the target was successfully resumed, and in non-async mode,
1107 we won't return back to MI interpreter code until the target
1108 is done running, so delaying the output of "^running" until then
1109 will make it impossible for frontend to know what's going on.
1111 In future (MI3), we'll be outputting "^done" here. */
1112 if (!running_result_record_printed
&& mi_proceeded
)
1114 fprintf_unfiltered (raw_stdout
, "%s^running\n",
1115 current_token
? current_token
: "");
1118 if (ptid_get_pid (ptid
) == -1)
1119 fprintf_unfiltered (raw_stdout
, "*running,thread-id=\"all\"\n");
1120 else if (ptid_is_pid (ptid
))
1124 /* Backwards compatibility. If there's only one inferior,
1125 output "all", otherwise, output each resumed thread
1127 iterate_over_inferiors (mi_inferior_count
, &count
);
1130 fprintf_unfiltered (raw_stdout
, "*running,thread-id=\"all\"\n");
1132 iterate_over_threads (mi_output_running_pid
, &ptid
);
1136 struct thread_info
*ti
= find_thread_ptid (ptid
);
1139 fprintf_unfiltered (raw_stdout
, "*running,thread-id=\"%d\"\n",
1143 if (!running_result_record_printed
&& mi_proceeded
)
1145 running_result_record_printed
= 1;
1146 /* This is what gdb used to do historically -- printing prompt even if
1147 it cannot actually accept any input. This will be surely removed
1148 for MI3, and may be removed even earlier. SYNC_EXECUTION is
1149 checked here because we only need to emit a prompt if a
1150 synchronous command was issued when the target is async. */
1151 if (!target_can_async_p () || sync_execution
)
1152 fputs_unfiltered ("(gdb) \n", raw_stdout
);
1154 gdb_flush (raw_stdout
);
1158 mi_on_resume (ptid_t ptid
)
1160 struct thread_info
*tp
= NULL
;
1161 struct switch_thru_all_uis state
;
1163 if (ptid_equal (ptid
, minus_one_ptid
) || ptid_is_pid (ptid
))
1164 tp
= inferior_thread ();
1166 tp
= find_thread_ptid (ptid
);
1168 /* Suppress output while calling an inferior function. */
1169 if (tp
->control
.in_infcall
)
1172 SWITCH_THRU_ALL_UIS (state
)
1174 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1175 struct cleanup
*old_chain
;
1180 old_chain
= make_cleanup_restore_target_terminal ();
1181 target_terminal_ours_for_output ();
1183 mi_on_resume_1 (ptid
);
1185 do_cleanups (old_chain
);
1190 mi_solib_loaded (struct so_list
*solib
)
1192 struct switch_thru_all_uis state
;
1194 SWITCH_THRU_ALL_UIS (state
)
1196 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1197 struct ui_out
*uiout
;
1198 struct cleanup
*old_chain
;
1203 uiout
= interp_ui_out (top_level_interpreter ());
1205 old_chain
= make_cleanup_restore_target_terminal ();
1206 target_terminal_ours_for_output ();
1208 fprintf_unfiltered (mi
->event_channel
, "library-loaded");
1210 ui_out_redirect (uiout
, mi
->event_channel
);
1212 ui_out_field_string (uiout
, "id", solib
->so_original_name
);
1213 ui_out_field_string (uiout
, "target-name", solib
->so_original_name
);
1214 ui_out_field_string (uiout
, "host-name", solib
->so_name
);
1215 ui_out_field_int (uiout
, "symbols-loaded", solib
->symbols_loaded
);
1216 if (!gdbarch_has_global_solist (target_gdbarch ()))
1218 ui_out_field_fmt (uiout
, "thread-group", "i%d",
1219 current_inferior ()->num
);
1222 ui_out_redirect (uiout
, NULL
);
1224 gdb_flush (mi
->event_channel
);
1226 do_cleanups (old_chain
);
1231 mi_solib_unloaded (struct so_list
*solib
)
1233 struct switch_thru_all_uis state
;
1235 SWITCH_THRU_ALL_UIS (state
)
1237 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1238 struct ui_out
*uiout
;
1239 struct cleanup
*old_chain
;
1244 uiout
= interp_ui_out (top_level_interpreter ());
1246 old_chain
= make_cleanup_restore_target_terminal ();
1247 target_terminal_ours_for_output ();
1249 fprintf_unfiltered (mi
->event_channel
, "library-unloaded");
1251 ui_out_redirect (uiout
, mi
->event_channel
);
1253 ui_out_field_string (uiout
, "id", solib
->so_original_name
);
1254 ui_out_field_string (uiout
, "target-name", solib
->so_original_name
);
1255 ui_out_field_string (uiout
, "host-name", solib
->so_name
);
1256 if (!gdbarch_has_global_solist (target_gdbarch ()))
1258 ui_out_field_fmt (uiout
, "thread-group", "i%d",
1259 current_inferior ()->num
);
1262 ui_out_redirect (uiout
, NULL
);
1264 gdb_flush (mi
->event_channel
);
1266 do_cleanups (old_chain
);
1270 /* Emit notification about the command parameter change. */
1273 mi_command_param_changed (const char *param
, const char *value
)
1275 struct switch_thru_all_uis state
;
1277 if (mi_suppress_notification
.cmd_param_changed
)
1280 SWITCH_THRU_ALL_UIS (state
)
1282 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1283 struct ui_out
*mi_uiout
;
1284 struct cleanup
*old_chain
;
1289 mi_uiout
= interp_ui_out (top_level_interpreter ());
1291 old_chain
= make_cleanup_restore_target_terminal ();
1292 target_terminal_ours_for_output ();
1294 fprintf_unfiltered (mi
->event_channel
, "cmd-param-changed");
1296 ui_out_redirect (mi_uiout
, mi
->event_channel
);
1298 ui_out_field_string (mi_uiout
, "param", param
);
1299 ui_out_field_string (mi_uiout
, "value", value
);
1301 ui_out_redirect (mi_uiout
, NULL
);
1303 gdb_flush (mi
->event_channel
);
1305 do_cleanups (old_chain
);
1309 /* Emit notification about the target memory change. */
1312 mi_memory_changed (struct inferior
*inferior
, CORE_ADDR memaddr
,
1313 ssize_t len
, const bfd_byte
*myaddr
)
1315 struct switch_thru_all_uis state
;
1317 if (mi_suppress_notification
.memory
)
1320 SWITCH_THRU_ALL_UIS (state
)
1322 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1323 struct ui_out
*mi_uiout
;
1324 struct obj_section
*sec
;
1325 struct cleanup
*old_chain
;
1330 mi_uiout
= interp_ui_out (top_level_interpreter ());
1332 old_chain
= make_cleanup_restore_target_terminal ();
1333 target_terminal_ours_for_output ();
1335 fprintf_unfiltered (mi
->event_channel
, "memory-changed");
1337 ui_out_redirect (mi_uiout
, mi
->event_channel
);
1339 ui_out_field_fmt (mi_uiout
, "thread-group", "i%d", inferior
->num
);
1340 ui_out_field_core_addr (mi_uiout
, "addr", target_gdbarch (), memaddr
);
1341 ui_out_field_fmt (mi_uiout
, "len", "%s", hex_string (len
));
1343 /* Append 'type=code' into notification if MEMADDR falls in the range of
1344 sections contain code. */
1345 sec
= find_pc_section (memaddr
);
1346 if (sec
!= NULL
&& sec
->objfile
!= NULL
)
1348 flagword flags
= bfd_get_section_flags (sec
->objfile
->obfd
,
1349 sec
->the_bfd_section
);
1351 if (flags
& SEC_CODE
)
1352 ui_out_field_string (mi_uiout
, "type", "code");
1355 ui_out_redirect (mi_uiout
, NULL
);
1357 gdb_flush (mi
->event_channel
);
1359 do_cleanups (old_chain
);
1364 report_initial_inferior (struct inferior
*inf
, void *closure
)
1366 /* This function is called from mi_interpreter_init, and since
1367 mi_inferior_added assumes that inferior is fully initialized
1368 and top_level_interpreter_data is set, we cannot call
1370 struct mi_interp
*mi
= (struct mi_interp
*) closure
;
1371 struct cleanup
*old_chain
;
1373 old_chain
= make_cleanup_restore_target_terminal ();
1374 target_terminal_ours_for_output ();
1376 fprintf_unfiltered (mi
->event_channel
,
1377 "thread-group-added,id=\"i%d\"",
1379 gdb_flush (mi
->event_channel
);
1381 do_cleanups (old_chain
);
1385 static struct ui_out
*
1386 mi_ui_out (struct interp
*interp
)
1388 struct mi_interp
*mi
= (struct mi_interp
*) interp_data (interp
);
1390 return mi
->mi_uiout
;
1393 /* Save the original value of raw_stdout here when logging, so we can
1394 restore correctly when done. */
1396 static struct ui_file
*saved_raw_stdout
;
1398 /* Do MI-specific logging actions; save raw_stdout, and change all
1399 the consoles to use the supplied ui-file(s). */
1402 mi_set_logging (struct interp
*interp
, int start_log
,
1403 struct ui_file
*out
, struct ui_file
*logfile
)
1405 struct mi_interp
*mi
= (struct mi_interp
*) interp_data (interp
);
1412 /* The tee created already is based on gdb_stdout, which for MI
1413 is a console and so we end up in an infinite loop of console
1414 writing to ui_file writing to console etc. So discard the
1415 existing tee (it hasn't been used yet, and MI won't ever use
1416 it), and create one based on raw_stdout instead. */
1419 ui_file_delete (out
);
1420 out
= tee_file_new (raw_stdout
, 0, logfile
, 0);
1423 saved_raw_stdout
= raw_stdout
;
1428 raw_stdout
= saved_raw_stdout
;
1429 saved_raw_stdout
= NULL
;
1432 mi_console_set_raw (mi
->out
, raw_stdout
);
1433 mi_console_set_raw (mi
->err
, raw_stdout
);
1434 mi_console_set_raw (mi
->log
, raw_stdout
);
1435 mi_console_set_raw (mi
->targ
, raw_stdout
);
1436 mi_console_set_raw (mi
->event_channel
, raw_stdout
);
1441 /* The MI interpreter's vtable. */
1443 static const struct interp_procs mi_interp_procs
=
1445 mi_interpreter_init
, /* init_proc */
1446 mi_interpreter_resume
, /* resume_proc */
1447 mi_interpreter_suspend
, /* suspend_proc */
1448 mi_interpreter_exec
, /* exec_proc */
1449 mi_ui_out
, /* ui_out_proc */
1450 mi_set_logging
, /* set_logging_proc */
1451 mi_command_loop
/* command_loop_proc */
1454 /* Factory for MI interpreters. */
1456 static struct interp
*
1457 mi_interp_factory (const char *name
)
1459 return interp_new (name
, &mi_interp_procs
, NULL
);
1462 extern initialize_file_ftype _initialize_mi_interp
; /* -Wmissing-prototypes */
1465 _initialize_mi_interp (void)
1467 /* The various interpreter levels. */
1468 interp_factory_register (INTERP_MI1
, mi_interp_factory
);
1469 interp_factory_register (INTERP_MI2
, mi_interp_factory
);
1470 interp_factory_register (INTERP_MI3
, mi_interp_factory
);
1471 interp_factory_register (INTERP_MI
, mi_interp_factory
);
1473 observer_attach_signal_received (mi_on_signal_received
);
1474 observer_attach_end_stepping_range (mi_on_end_stepping_range
);
1475 observer_attach_signal_exited (mi_on_signal_exited
);
1476 observer_attach_exited (mi_on_exited
);
1477 observer_attach_no_history (mi_on_no_history
);
1478 observer_attach_new_thread (mi_new_thread
);
1479 observer_attach_thread_exit (mi_thread_exit
);
1480 observer_attach_inferior_added (mi_inferior_added
);
1481 observer_attach_inferior_appeared (mi_inferior_appeared
);
1482 observer_attach_inferior_exit (mi_inferior_exit
);
1483 observer_attach_inferior_removed (mi_inferior_removed
);
1484 observer_attach_record_changed (mi_record_changed
);
1485 observer_attach_normal_stop (mi_on_normal_stop
);
1486 observer_attach_target_resumed (mi_on_resume
);
1487 observer_attach_solib_loaded (mi_solib_loaded
);
1488 observer_attach_solib_unloaded (mi_solib_unloaded
);
1489 observer_attach_about_to_proceed (mi_about_to_proceed
);
1490 observer_attach_traceframe_changed (mi_traceframe_changed
);
1491 observer_attach_tsv_created (mi_tsv_created
);
1492 observer_attach_tsv_deleted (mi_tsv_deleted
);
1493 observer_attach_tsv_modified (mi_tsv_modified
);
1494 observer_attach_breakpoint_created (mi_breakpoint_created
);
1495 observer_attach_breakpoint_deleted (mi_breakpoint_deleted
);
1496 observer_attach_breakpoint_modified (mi_breakpoint_modified
);
1497 observer_attach_command_param_changed (mi_command_param_changed
);
1498 observer_attach_memory_changed (mi_memory_changed
);
1499 observer_attach_sync_execution_done (mi_on_sync_execution_done
);