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 struct ui
*ui
= current_ui
;
289 mi_execute_command (cmd
, stdin
== ui
->instream
);
292 /* Observer for the synchronous_command_done notification. */
295 mi_on_sync_execution_done (void)
297 struct ui
*ui
= current_ui
;
298 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
303 /* If MI is sync, then output the MI prompt now, indicating we're
304 ready for further input. */
307 fputs_unfiltered ("(gdb) \n", raw_stdout
);
308 gdb_flush (raw_stdout
);
312 /* mi_execute_command_wrapper wrapper suitable for INPUT_HANDLER. */
315 mi_execute_command_input_handler (char *cmd
)
317 mi_execute_command_wrapper (cmd
);
319 /* Print a prompt, indicating we're ready for further input, unless
320 we just started a synchronous command. In that case, we're about
321 to go back to the event loop and will output the prompt in the
322 'synchronous_command_done' observer when the target next
326 fputs_unfiltered ("(gdb) \n", raw_stdout
);
327 gdb_flush (raw_stdout
);
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 fputs_unfiltered ("(gdb) \n", raw_stdout
);
340 gdb_flush (raw_stdout
);
346 mi_new_thread (struct thread_info
*t
)
348 struct inferior
*inf
= find_inferior_ptid (t
->ptid
);
349 struct switch_thru_all_uis state
;
353 SWITCH_THRU_ALL_UIS (state
)
355 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
356 struct cleanup
*old_chain
;
361 old_chain
= make_cleanup_restore_target_terminal ();
362 target_terminal_ours_for_output ();
364 fprintf_unfiltered (mi
->event_channel
,
365 "thread-created,id=\"%d\",group-id=\"i%d\"",
366 t
->global_num
, inf
->num
);
367 gdb_flush (mi
->event_channel
);
369 do_cleanups (old_chain
);
374 mi_thread_exit (struct thread_info
*t
, int silent
)
376 struct switch_thru_all_uis state
;
381 SWITCH_THRU_ALL_UIS (state
)
383 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
384 struct cleanup
*old_chain
;
389 old_chain
= make_cleanup_restore_target_terminal ();
390 target_terminal_ours_for_output ();
391 fprintf_unfiltered (mi
->event_channel
,
392 "thread-exited,id=\"%d\",group-id=\"i%d\"",
393 t
->global_num
, t
->inf
->num
);
394 gdb_flush (mi
->event_channel
);
396 do_cleanups (old_chain
);
400 /* Emit notification on changing the state of record. */
403 mi_record_changed (struct inferior
*inferior
, int started
, const char *method
,
406 struct switch_thru_all_uis state
;
408 SWITCH_THRU_ALL_UIS (state
)
410 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
411 struct cleanup
*old_chain
;
416 old_chain
= make_cleanup_restore_target_terminal ();
417 target_terminal_ours_for_output ();
423 fprintf_unfiltered (mi
->event_channel
,
424 "record-started,thread-group=\"i%d\","
425 "method=\"%s\",format=\"%s\"",
426 inferior
->num
, method
, format
);
430 fprintf_unfiltered (mi
->event_channel
,
431 "record-started,thread-group=\"i%d\","
433 inferior
->num
, method
);
438 fprintf_unfiltered (mi
->event_channel
,
439 "record-stopped,thread-group=\"i%d\"",
443 gdb_flush (mi
->event_channel
);
445 do_cleanups (old_chain
);
450 mi_inferior_added (struct inferior
*inf
)
452 struct switch_thru_all_uis state
;
454 SWITCH_THRU_ALL_UIS (state
)
456 struct interp
*interp
;
457 struct mi_interp
*mi
;
458 struct cleanup
*old_chain
;
460 /* We'll be called once for the initial inferior, before the top
461 level interpreter is set. */
462 interp
= top_level_interpreter ();
466 mi
= as_mi_interp (interp
);
470 old_chain
= make_cleanup_restore_target_terminal ();
471 target_terminal_ours_for_output ();
473 fprintf_unfiltered (mi
->event_channel
,
474 "thread-group-added,id=\"i%d\"",
476 gdb_flush (mi
->event_channel
);
478 do_cleanups (old_chain
);
483 mi_inferior_appeared (struct inferior
*inf
)
485 struct switch_thru_all_uis state
;
487 SWITCH_THRU_ALL_UIS (state
)
489 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
490 struct cleanup
*old_chain
;
495 old_chain
= make_cleanup_restore_target_terminal ();
496 target_terminal_ours_for_output ();
498 fprintf_unfiltered (mi
->event_channel
,
499 "thread-group-started,id=\"i%d\",pid=\"%d\"",
501 gdb_flush (mi
->event_channel
);
502 do_cleanups (old_chain
);
507 mi_inferior_exit (struct inferior
*inf
)
509 struct switch_thru_all_uis state
;
511 SWITCH_THRU_ALL_UIS (state
)
513 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
514 struct cleanup
*old_chain
;
519 old_chain
= make_cleanup_restore_target_terminal ();
520 target_terminal_ours_for_output ();
522 if (inf
->has_exit_code
)
523 fprintf_unfiltered (mi
->event_channel
,
524 "thread-group-exited,id=\"i%d\",exit-code=\"%s\"",
525 inf
->num
, int_string (inf
->exit_code
, 8, 0, 0, 1));
527 fprintf_unfiltered (mi
->event_channel
,
528 "thread-group-exited,id=\"i%d\"", inf
->num
);
530 gdb_flush (mi
->event_channel
);
531 do_cleanups (old_chain
);
536 mi_inferior_removed (struct inferior
*inf
)
538 struct switch_thru_all_uis state
;
540 SWITCH_THRU_ALL_UIS (state
)
542 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
543 struct cleanup
*old_chain
;
548 old_chain
= make_cleanup_restore_target_terminal ();
549 target_terminal_ours_for_output ();
551 fprintf_unfiltered (mi
->event_channel
,
552 "thread-group-removed,id=\"i%d\"",
554 gdb_flush (mi
->event_channel
);
556 do_cleanups (old_chain
);
560 /* Return the MI interpreter, if it is active -- either because it's
561 the top-level interpreter or the interpreter executing the current
562 command. Returns NULL if the MI interpreter is not being used. */
564 static struct mi_interp
*
565 find_mi_interp (void)
567 struct mi_interp
*mi
;
569 mi
= as_mi_interp (top_level_interpreter ());
573 mi
= as_mi_interp (command_interp ());
580 /* Observers for several run control events that print why the
581 inferior has stopped to both the the MI event channel and to the MI
582 console. If the MI interpreter is not active, print nothing. */
584 /* Observer for the signal_received notification. */
587 mi_on_signal_received (enum gdb_signal siggnal
)
589 struct switch_thru_all_uis state
;
591 SWITCH_THRU_ALL_UIS (state
)
593 struct mi_interp
*mi
= find_mi_interp ();
598 print_signal_received_reason (mi
->mi_uiout
, siggnal
);
599 print_signal_received_reason (mi
->cli_uiout
, siggnal
);
603 /* Observer for the end_stepping_range notification. */
606 mi_on_end_stepping_range (void)
608 struct switch_thru_all_uis state
;
610 SWITCH_THRU_ALL_UIS (state
)
612 struct mi_interp
*mi
= find_mi_interp ();
617 print_end_stepping_range_reason (mi
->mi_uiout
);
618 print_end_stepping_range_reason (mi
->cli_uiout
);
622 /* Observer for the signal_exited notification. */
625 mi_on_signal_exited (enum gdb_signal siggnal
)
627 struct switch_thru_all_uis state
;
629 SWITCH_THRU_ALL_UIS (state
)
631 struct mi_interp
*mi
= find_mi_interp ();
636 print_signal_exited_reason (mi
->mi_uiout
, siggnal
);
637 print_signal_exited_reason (mi
->cli_uiout
, siggnal
);
641 /* Observer for the exited notification. */
644 mi_on_exited (int exitstatus
)
646 struct switch_thru_all_uis state
;
648 SWITCH_THRU_ALL_UIS (state
)
650 struct mi_interp
*mi
= find_mi_interp ();
655 print_exited_reason (mi
->mi_uiout
, exitstatus
);
656 print_exited_reason (mi
->cli_uiout
, exitstatus
);
660 /* Observer for the no_history notification. */
663 mi_on_no_history (void)
665 struct switch_thru_all_uis state
;
667 SWITCH_THRU_ALL_UIS (state
)
669 struct mi_interp
*mi
= find_mi_interp ();
674 print_no_history_reason (mi
->mi_uiout
);
675 print_no_history_reason (mi
->cli_uiout
);
680 mi_on_normal_stop_1 (struct bpstats
*bs
, int print_frame
)
682 /* Since this can be called when CLI command is executing,
683 using cli interpreter, be sure to use MI uiout for output,
684 not the current one. */
685 struct ui_out
*mi_uiout
= interp_ui_out (top_level_interpreter ());
689 struct thread_info
*tp
;
692 tp
= inferior_thread ();
694 if (tp
->thread_fsm
!= NULL
695 && thread_fsm_finished_p (tp
->thread_fsm
))
697 enum async_reply_reason reason
;
699 reason
= thread_fsm_async_reply_reason (tp
->thread_fsm
);
700 ui_out_field_string (mi_uiout
, "reason",
701 async_reason_lookup (reason
));
703 print_stop_event (mi_uiout
);
705 /* Breakpoint hits should always be mirrored to the console.
706 Deciding what to mirror to the console wrt to breakpoints and
707 random stops gets messy real fast. E.g., say "s" trips on a
708 breakpoint. We'd clearly want to mirror the event to the
709 console in this case. But what about more complicated cases
710 like "s&; thread n; s&", and one of those steps spawning a
711 new thread, and that thread hitting a breakpoint? It's
712 impossible in general to track whether the thread had any
713 relation to the commands that had been executed. So we just
714 simplify and always mirror breakpoints and random events to
717 OTOH, we should print the source line to the console when
718 stepping or other similar commands, iff the step was started
719 by a console command, but not if it was started with
720 -exec-step or similar. */
721 if ((bpstat_what (tp
->control
.stop_bpstat
).main_action
722 == BPSTAT_WHAT_STOP_NOISY
)
723 || !(tp
->thread_fsm
!= NULL
724 && thread_fsm_finished_p (tp
->thread_fsm
))
725 || (tp
->control
.command_interp
!= NULL
726 && tp
->control
.command_interp
!= top_level_interpreter ()))
729 = (struct mi_interp
*) top_level_interpreter_data ();
731 print_stop_event (mi
->cli_uiout
);
734 tp
= inferior_thread ();
735 ui_out_field_int (mi_uiout
, "thread-id", tp
->global_num
);
738 struct cleanup
*back_to
= make_cleanup_ui_out_list_begin_end
739 (mi_uiout
, "stopped-threads");
741 ui_out_field_int (mi_uiout
, NULL
, tp
->global_num
);
742 do_cleanups (back_to
);
745 ui_out_field_string (mi_uiout
, "stopped-threads", "all");
747 core
= target_core_of_thread (inferior_ptid
);
749 ui_out_field_int (mi_uiout
, "core", core
);
752 fputs_unfiltered ("*stopped", raw_stdout
);
753 mi_out_put (mi_uiout
, raw_stdout
);
754 mi_out_rewind (mi_uiout
);
755 mi_print_timing_maybe ();
756 fputs_unfiltered ("\n", raw_stdout
);
757 gdb_flush (raw_stdout
);
761 mi_on_normal_stop (struct bpstats
*bs
, int print_frame
)
763 struct switch_thru_all_uis state
;
765 SWITCH_THRU_ALL_UIS (state
)
767 if (as_mi_interp (top_level_interpreter ()) == NULL
)
770 mi_on_normal_stop_1 (bs
, print_frame
);
775 mi_about_to_proceed (void)
777 /* Suppress output while calling an inferior function. */
779 if (!ptid_equal (inferior_ptid
, null_ptid
))
781 struct thread_info
*tp
= inferior_thread ();
783 if (tp
->control
.in_infcall
)
790 /* When the element is non-zero, no MI notifications will be emitted in
791 response to the corresponding observers. */
793 struct mi_suppress_notification mi_suppress_notification
=
800 /* Emit notification on changing a traceframe. */
803 mi_traceframe_changed (int tfnum
, int tpnum
)
805 struct switch_thru_all_uis state
;
807 if (mi_suppress_notification
.traceframe
)
810 SWITCH_THRU_ALL_UIS (state
)
812 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
813 struct cleanup
*old_chain
;
818 old_chain
= make_cleanup_restore_target_terminal ();
819 target_terminal_ours_for_output ();
822 fprintf_unfiltered (mi
->event_channel
, "traceframe-changed,"
823 "num=\"%d\",tracepoint=\"%d\"\n",
826 fprintf_unfiltered (mi
->event_channel
, "traceframe-changed,end");
828 gdb_flush (mi
->event_channel
);
830 do_cleanups (old_chain
);
834 /* Emit notification on creating a trace state variable. */
837 mi_tsv_created (const struct trace_state_variable
*tsv
)
839 struct switch_thru_all_uis state
;
841 SWITCH_THRU_ALL_UIS (state
)
843 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
844 struct cleanup
*old_chain
;
849 old_chain
= make_cleanup_restore_target_terminal ();
850 target_terminal_ours_for_output ();
852 fprintf_unfiltered (mi
->event_channel
, "tsv-created,"
853 "name=\"%s\",initial=\"%s\"\n",
854 tsv
->name
, plongest (tsv
->initial_value
));
856 gdb_flush (mi
->event_channel
);
858 do_cleanups (old_chain
);
862 /* Emit notification on deleting a trace state variable. */
865 mi_tsv_deleted (const struct trace_state_variable
*tsv
)
867 struct switch_thru_all_uis state
;
869 SWITCH_THRU_ALL_UIS (state
)
871 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
872 struct cleanup
*old_chain
;
877 old_chain
= make_cleanup_restore_target_terminal ();
878 target_terminal_ours_for_output ();
881 fprintf_unfiltered (mi
->event_channel
, "tsv-deleted,"
882 "name=\"%s\"\n", tsv
->name
);
884 fprintf_unfiltered (mi
->event_channel
, "tsv-deleted\n");
886 gdb_flush (mi
->event_channel
);
888 do_cleanups (old_chain
);
892 /* Emit notification on modifying a trace state variable. */
895 mi_tsv_modified (const struct trace_state_variable
*tsv
)
897 struct switch_thru_all_uis state
;
899 SWITCH_THRU_ALL_UIS (state
)
901 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
902 struct ui_out
*mi_uiout
;
903 struct cleanup
*old_chain
;
908 mi_uiout
= interp_ui_out (top_level_interpreter ());
910 old_chain
= make_cleanup_restore_target_terminal ();
911 target_terminal_ours_for_output ();
913 fprintf_unfiltered (mi
->event_channel
,
916 ui_out_redirect (mi_uiout
, mi
->event_channel
);
918 ui_out_field_string (mi_uiout
, "name", tsv
->name
);
919 ui_out_field_string (mi_uiout
, "initial",
920 plongest (tsv
->initial_value
));
921 if (tsv
->value_known
)
922 ui_out_field_string (mi_uiout
, "current", plongest (tsv
->value
));
924 ui_out_redirect (mi_uiout
, NULL
);
926 gdb_flush (mi
->event_channel
);
928 do_cleanups (old_chain
);
932 /* Emit notification about a created breakpoint. */
935 mi_breakpoint_created (struct breakpoint
*b
)
937 struct switch_thru_all_uis state
;
939 if (mi_suppress_notification
.breakpoint
)
945 SWITCH_THRU_ALL_UIS (state
)
947 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
948 struct ui_out
*mi_uiout
;
949 struct cleanup
*old_chain
;
954 mi_uiout
= interp_ui_out (top_level_interpreter ());
956 old_chain
= make_cleanup_restore_target_terminal ();
957 target_terminal_ours_for_output ();
959 fprintf_unfiltered (mi
->event_channel
,
960 "breakpoint-created");
961 /* We want the output from gdb_breakpoint_query to go to
962 mi->event_channel. One approach would be to just call
963 gdb_breakpoint_query, and then use mi_out_put to send the current
964 content of mi_outout into mi->event_channel. However, that will
965 break if anything is output to mi_uiout prior to calling the
966 breakpoint_created notifications. So, we use
968 ui_out_redirect (mi_uiout
, mi
->event_channel
);
971 gdb_breakpoint_query (mi_uiout
, b
->number
, NULL
);
973 CATCH (e
, RETURN_MASK_ERROR
)
978 ui_out_redirect (mi_uiout
, NULL
);
980 gdb_flush (mi
->event_channel
);
982 do_cleanups (old_chain
);
986 /* Emit notification about deleted breakpoint. */
989 mi_breakpoint_deleted (struct breakpoint
*b
)
991 struct switch_thru_all_uis state
;
993 if (mi_suppress_notification
.breakpoint
)
999 SWITCH_THRU_ALL_UIS (state
)
1001 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1002 struct cleanup
*old_chain
;
1007 old_chain
= make_cleanup_restore_target_terminal ();
1008 target_terminal_ours_for_output ();
1010 fprintf_unfiltered (mi
->event_channel
, "breakpoint-deleted,id=\"%d\"",
1013 gdb_flush (mi
->event_channel
);
1015 do_cleanups (old_chain
);
1019 /* Emit notification about modified breakpoint. */
1022 mi_breakpoint_modified (struct breakpoint
*b
)
1024 struct switch_thru_all_uis state
;
1026 if (mi_suppress_notification
.breakpoint
)
1032 SWITCH_THRU_ALL_UIS (state
)
1034 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1035 struct cleanup
*old_chain
;
1040 old_chain
= make_cleanup_restore_target_terminal ();
1041 target_terminal_ours_for_output ();
1042 fprintf_unfiltered (mi
->event_channel
,
1043 "breakpoint-modified");
1044 /* We want the output from gdb_breakpoint_query to go to
1045 mi->event_channel. One approach would be to just call
1046 gdb_breakpoint_query, and then use mi_out_put to send the current
1047 content of mi_outout into mi->event_channel. However, that will
1048 break if anything is output to mi_uiout prior to calling the
1049 breakpoint_created notifications. So, we use
1051 ui_out_redirect (mi
->mi_uiout
, mi
->event_channel
);
1054 gdb_breakpoint_query (mi
->mi_uiout
, b
->number
, NULL
);
1056 CATCH (e
, RETURN_MASK_ERROR
)
1061 ui_out_redirect (mi
->mi_uiout
, NULL
);
1063 gdb_flush (mi
->event_channel
);
1065 do_cleanups (old_chain
);
1070 mi_output_running_pid (struct thread_info
*info
, void *arg
)
1072 ptid_t
*ptid
= (ptid_t
*) arg
;
1073 struct switch_thru_all_uis state
;
1075 SWITCH_THRU_ALL_UIS (state
)
1077 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1082 if (ptid_get_pid (*ptid
) == ptid_get_pid (info
->ptid
))
1083 fprintf_unfiltered (raw_stdout
,
1084 "*running,thread-id=\"%d\"\n",
1092 mi_inferior_count (struct inferior
*inf
, void *arg
)
1096 int *count_p
= (int *) arg
;
1104 mi_on_resume_1 (ptid_t ptid
)
1106 /* To cater for older frontends, emit ^running, but do it only once
1107 per each command. We do it here, since at this point we know
1108 that the target was successfully resumed, and in non-async mode,
1109 we won't return back to MI interpreter code until the target
1110 is done running, so delaying the output of "^running" until then
1111 will make it impossible for frontend to know what's going on.
1113 In future (MI3), we'll be outputting "^done" here. */
1114 if (!running_result_record_printed
&& mi_proceeded
)
1116 fprintf_unfiltered (raw_stdout
, "%s^running\n",
1117 current_token
? current_token
: "");
1120 if (ptid_get_pid (ptid
) == -1)
1121 fprintf_unfiltered (raw_stdout
, "*running,thread-id=\"all\"\n");
1122 else if (ptid_is_pid (ptid
))
1126 /* Backwards compatibility. If there's only one inferior,
1127 output "all", otherwise, output each resumed thread
1129 iterate_over_inferiors (mi_inferior_count
, &count
);
1132 fprintf_unfiltered (raw_stdout
, "*running,thread-id=\"all\"\n");
1134 iterate_over_threads (mi_output_running_pid
, &ptid
);
1138 struct thread_info
*ti
= find_thread_ptid (ptid
);
1141 fprintf_unfiltered (raw_stdout
, "*running,thread-id=\"%d\"\n",
1145 if (!running_result_record_printed
&& mi_proceeded
)
1147 running_result_record_printed
= 1;
1148 /* This is what gdb used to do historically -- printing prompt even if
1149 it cannot actually accept any input. This will be surely removed
1150 for MI3, and may be removed even earlier. SYNC_EXECUTION is
1151 checked here because we only need to emit a prompt if a
1152 synchronous command was issued when the target is async. */
1153 if (!target_can_async_p () || sync_execution
)
1154 fputs_unfiltered ("(gdb) \n", raw_stdout
);
1156 gdb_flush (raw_stdout
);
1160 mi_on_resume (ptid_t ptid
)
1162 struct thread_info
*tp
= NULL
;
1163 struct switch_thru_all_uis state
;
1165 if (ptid_equal (ptid
, minus_one_ptid
) || ptid_is_pid (ptid
))
1166 tp
= inferior_thread ();
1168 tp
= find_thread_ptid (ptid
);
1170 /* Suppress output while calling an inferior function. */
1171 if (tp
->control
.in_infcall
)
1174 SWITCH_THRU_ALL_UIS (state
)
1176 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1177 struct cleanup
*old_chain
;
1182 old_chain
= make_cleanup_restore_target_terminal ();
1183 target_terminal_ours_for_output ();
1185 mi_on_resume_1 (ptid
);
1187 do_cleanups (old_chain
);
1192 mi_solib_loaded (struct so_list
*solib
)
1194 struct switch_thru_all_uis state
;
1196 SWITCH_THRU_ALL_UIS (state
)
1198 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1199 struct ui_out
*uiout
;
1200 struct cleanup
*old_chain
;
1205 uiout
= interp_ui_out (top_level_interpreter ());
1207 old_chain
= make_cleanup_restore_target_terminal ();
1208 target_terminal_ours_for_output ();
1210 fprintf_unfiltered (mi
->event_channel
, "library-loaded");
1212 ui_out_redirect (uiout
, mi
->event_channel
);
1214 ui_out_field_string (uiout
, "id", solib
->so_original_name
);
1215 ui_out_field_string (uiout
, "target-name", solib
->so_original_name
);
1216 ui_out_field_string (uiout
, "host-name", solib
->so_name
);
1217 ui_out_field_int (uiout
, "symbols-loaded", solib
->symbols_loaded
);
1218 if (!gdbarch_has_global_solist (target_gdbarch ()))
1220 ui_out_field_fmt (uiout
, "thread-group", "i%d",
1221 current_inferior ()->num
);
1224 ui_out_redirect (uiout
, NULL
);
1226 gdb_flush (mi
->event_channel
);
1228 do_cleanups (old_chain
);
1233 mi_solib_unloaded (struct so_list
*solib
)
1235 struct switch_thru_all_uis state
;
1237 SWITCH_THRU_ALL_UIS (state
)
1239 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1240 struct ui_out
*uiout
;
1241 struct cleanup
*old_chain
;
1246 uiout
= interp_ui_out (top_level_interpreter ());
1248 old_chain
= make_cleanup_restore_target_terminal ();
1249 target_terminal_ours_for_output ();
1251 fprintf_unfiltered (mi
->event_channel
, "library-unloaded");
1253 ui_out_redirect (uiout
, mi
->event_channel
);
1255 ui_out_field_string (uiout
, "id", solib
->so_original_name
);
1256 ui_out_field_string (uiout
, "target-name", solib
->so_original_name
);
1257 ui_out_field_string (uiout
, "host-name", solib
->so_name
);
1258 if (!gdbarch_has_global_solist (target_gdbarch ()))
1260 ui_out_field_fmt (uiout
, "thread-group", "i%d",
1261 current_inferior ()->num
);
1264 ui_out_redirect (uiout
, NULL
);
1266 gdb_flush (mi
->event_channel
);
1268 do_cleanups (old_chain
);
1272 /* Emit notification about the command parameter change. */
1275 mi_command_param_changed (const char *param
, const char *value
)
1277 struct switch_thru_all_uis state
;
1279 if (mi_suppress_notification
.cmd_param_changed
)
1282 SWITCH_THRU_ALL_UIS (state
)
1284 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1285 struct ui_out
*mi_uiout
;
1286 struct cleanup
*old_chain
;
1291 mi_uiout
= interp_ui_out (top_level_interpreter ());
1293 old_chain
= make_cleanup_restore_target_terminal ();
1294 target_terminal_ours_for_output ();
1296 fprintf_unfiltered (mi
->event_channel
, "cmd-param-changed");
1298 ui_out_redirect (mi_uiout
, mi
->event_channel
);
1300 ui_out_field_string (mi_uiout
, "param", param
);
1301 ui_out_field_string (mi_uiout
, "value", value
);
1303 ui_out_redirect (mi_uiout
, NULL
);
1305 gdb_flush (mi
->event_channel
);
1307 do_cleanups (old_chain
);
1311 /* Emit notification about the target memory change. */
1314 mi_memory_changed (struct inferior
*inferior
, CORE_ADDR memaddr
,
1315 ssize_t len
, const bfd_byte
*myaddr
)
1317 struct switch_thru_all_uis state
;
1319 if (mi_suppress_notification
.memory
)
1322 SWITCH_THRU_ALL_UIS (state
)
1324 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1325 struct ui_out
*mi_uiout
;
1326 struct obj_section
*sec
;
1327 struct cleanup
*old_chain
;
1332 mi_uiout
= interp_ui_out (top_level_interpreter ());
1334 old_chain
= make_cleanup_restore_target_terminal ();
1335 target_terminal_ours_for_output ();
1337 fprintf_unfiltered (mi
->event_channel
, "memory-changed");
1339 ui_out_redirect (mi_uiout
, mi
->event_channel
);
1341 ui_out_field_fmt (mi_uiout
, "thread-group", "i%d", inferior
->num
);
1342 ui_out_field_core_addr (mi_uiout
, "addr", target_gdbarch (), memaddr
);
1343 ui_out_field_fmt (mi_uiout
, "len", "%s", hex_string (len
));
1345 /* Append 'type=code' into notification if MEMADDR falls in the range of
1346 sections contain code. */
1347 sec
= find_pc_section (memaddr
);
1348 if (sec
!= NULL
&& sec
->objfile
!= NULL
)
1350 flagword flags
= bfd_get_section_flags (sec
->objfile
->obfd
,
1351 sec
->the_bfd_section
);
1353 if (flags
& SEC_CODE
)
1354 ui_out_field_string (mi_uiout
, "type", "code");
1357 ui_out_redirect (mi_uiout
, NULL
);
1359 gdb_flush (mi
->event_channel
);
1361 do_cleanups (old_chain
);
1366 report_initial_inferior (struct inferior
*inf
, void *closure
)
1368 /* This function is called from mi_interpreter_init, and since
1369 mi_inferior_added assumes that inferior is fully initialized
1370 and top_level_interpreter_data is set, we cannot call
1372 struct mi_interp
*mi
= (struct mi_interp
*) closure
;
1373 struct cleanup
*old_chain
;
1375 old_chain
= make_cleanup_restore_target_terminal ();
1376 target_terminal_ours_for_output ();
1378 fprintf_unfiltered (mi
->event_channel
,
1379 "thread-group-added,id=\"i%d\"",
1381 gdb_flush (mi
->event_channel
);
1383 do_cleanups (old_chain
);
1387 static struct ui_out
*
1388 mi_ui_out (struct interp
*interp
)
1390 struct mi_interp
*mi
= (struct mi_interp
*) interp_data (interp
);
1392 return mi
->mi_uiout
;
1395 /* Save the original value of raw_stdout here when logging, so we can
1396 restore correctly when done. */
1398 static struct ui_file
*saved_raw_stdout
;
1400 /* Do MI-specific logging actions; save raw_stdout, and change all
1401 the consoles to use the supplied ui-file(s). */
1404 mi_set_logging (struct interp
*interp
, int start_log
,
1405 struct ui_file
*out
, struct ui_file
*logfile
)
1407 struct mi_interp
*mi
= (struct mi_interp
*) interp_data (interp
);
1414 /* The tee created already is based on gdb_stdout, which for MI
1415 is a console and so we end up in an infinite loop of console
1416 writing to ui_file writing to console etc. So discard the
1417 existing tee (it hasn't been used yet, and MI won't ever use
1418 it), and create one based on raw_stdout instead. */
1421 ui_file_delete (out
);
1422 out
= tee_file_new (raw_stdout
, 0, logfile
, 0);
1425 saved_raw_stdout
= raw_stdout
;
1430 raw_stdout
= saved_raw_stdout
;
1431 saved_raw_stdout
= NULL
;
1434 mi_console_set_raw (mi
->out
, raw_stdout
);
1435 mi_console_set_raw (mi
->err
, raw_stdout
);
1436 mi_console_set_raw (mi
->log
, raw_stdout
);
1437 mi_console_set_raw (mi
->targ
, raw_stdout
);
1438 mi_console_set_raw (mi
->event_channel
, raw_stdout
);
1443 /* The MI interpreter's vtable. */
1445 static const struct interp_procs mi_interp_procs
=
1447 mi_interpreter_init
, /* init_proc */
1448 mi_interpreter_resume
, /* resume_proc */
1449 mi_interpreter_suspend
, /* suspend_proc */
1450 mi_interpreter_exec
, /* exec_proc */
1451 mi_ui_out
, /* ui_out_proc */
1452 mi_set_logging
, /* set_logging_proc */
1453 mi_command_loop
/* command_loop_proc */
1456 /* Factory for MI interpreters. */
1458 static struct interp
*
1459 mi_interp_factory (const char *name
)
1461 return interp_new (name
, &mi_interp_procs
, NULL
);
1464 extern initialize_file_ftype _initialize_mi_interp
; /* -Wmissing-prototypes */
1467 _initialize_mi_interp (void)
1469 /* The various interpreter levels. */
1470 interp_factory_register (INTERP_MI1
, mi_interp_factory
);
1471 interp_factory_register (INTERP_MI2
, mi_interp_factory
);
1472 interp_factory_register (INTERP_MI3
, mi_interp_factory
);
1473 interp_factory_register (INTERP_MI
, mi_interp_factory
);
1475 observer_attach_signal_received (mi_on_signal_received
);
1476 observer_attach_end_stepping_range (mi_on_end_stepping_range
);
1477 observer_attach_signal_exited (mi_on_signal_exited
);
1478 observer_attach_exited (mi_on_exited
);
1479 observer_attach_no_history (mi_on_no_history
);
1480 observer_attach_new_thread (mi_new_thread
);
1481 observer_attach_thread_exit (mi_thread_exit
);
1482 observer_attach_inferior_added (mi_inferior_added
);
1483 observer_attach_inferior_appeared (mi_inferior_appeared
);
1484 observer_attach_inferior_exit (mi_inferior_exit
);
1485 observer_attach_inferior_removed (mi_inferior_removed
);
1486 observer_attach_record_changed (mi_record_changed
);
1487 observer_attach_normal_stop (mi_on_normal_stop
);
1488 observer_attach_target_resumed (mi_on_resume
);
1489 observer_attach_solib_loaded (mi_solib_loaded
);
1490 observer_attach_solib_unloaded (mi_solib_unloaded
);
1491 observer_attach_about_to_proceed (mi_about_to_proceed
);
1492 observer_attach_traceframe_changed (mi_traceframe_changed
);
1493 observer_attach_tsv_created (mi_tsv_created
);
1494 observer_attach_tsv_deleted (mi_tsv_deleted
);
1495 observer_attach_tsv_modified (mi_tsv_modified
);
1496 observer_attach_breakpoint_created (mi_breakpoint_created
);
1497 observer_attach_breakpoint_deleted (mi_breakpoint_deleted
);
1498 observer_attach_breakpoint_modified (mi_breakpoint_modified
);
1499 observer_attach_command_param_changed (mi_command_param_changed
);
1500 observer_attach_memory_changed (mi_memory_changed
);
1501 observer_attach_sync_execution_done (mi_on_sync_execution_done
);