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 struct ui
*ui
= current_ui
;
98 fputs_unfiltered ("(gdb) \n", mi
->raw_stdout
);
99 gdb_flush (mi
->raw_stdout
);
100 ui
->prompt_state
= PROMPTED
;
103 /* Returns the INTERP's data cast as mi_interp if INTERP is an MI, and
104 returns NULL otherwise. */
106 static struct mi_interp
*
107 as_mi_interp (struct interp
*interp
)
109 if (ui_out_is_mi_like_p (interp_ui_out (interp
)))
110 return (struct mi_interp
*) interp_data (interp
);
115 mi_interpreter_init (struct interp
*interp
, int top_level
)
117 struct mi_interp
*mi
= XNEW (struct mi_interp
);
121 /* Store the current output channel, so that we can create a console
122 channel that encapsulates and prefixes all gdb_output-type bits
123 coming from the rest of the debugger. */
124 mi
->raw_stdout
= gdb_stdout
;
126 /* Create MI console channels, each with a different prefix so they
127 can be distinguished. */
128 mi
->out
= mi_console_file_new (mi
->raw_stdout
, "~", '"');
129 mi
->err
= mi_console_file_new (mi
->raw_stdout
, "&", '"');
131 mi
->targ
= mi_console_file_new (mi
->raw_stdout
, "@", '"');
132 mi
->event_channel
= mi_console_file_new (mi
->raw_stdout
, "=", 0);
134 name
= interp_name (interp
);
135 /* INTERP_MI selects the most recent released version. "mi2" was
136 released as part of GDB 6.0. */
137 if (strcmp (name
, INTERP_MI
) == 0)
139 else if (strcmp (name
, INTERP_MI1
) == 0)
141 else if (strcmp (name
, INTERP_MI2
) == 0)
143 else if (strcmp (name
, INTERP_MI3
) == 0)
146 gdb_assert_not_reached ("unhandled MI version");
148 mi
->mi_uiout
= mi_out_new (mi_version
);
149 mi
->cli_uiout
= cli_out_new (mi
->out
);
153 /* The initial inferior is created before this function is
154 called, so we need to report it explicitly. Use iteration in
155 case future version of GDB creates more than one inferior
157 iterate_over_inferiors (report_initial_inferior
, mi
);
164 mi_interpreter_resume (void *data
)
166 struct mi_interp
*mi
= (struct mi_interp
*) data
;
167 struct ui
*ui
= current_ui
;
169 /* As per hack note in mi_interpreter_init, swap in the output
171 gdb_setup_readline (0);
173 ui
->call_readline
= gdb_readline_no_editing_callback
;
174 ui
->input_handler
= mi_execute_command_input_handler
;
176 gdb_stdout
= mi
->out
;
177 /* Route error and log output through the MI. */
178 gdb_stderr
= mi
->err
;
179 gdb_stdlog
= mi
->log
;
180 /* Route target output through the MI. */
181 gdb_stdtarg
= mi
->targ
;
182 /* Route target error through the MI as well. */
183 gdb_stdtargerr
= mi
->targ
;
185 /* Replace all the hooks that we know about. There really needs to
186 be a better way of doing this... */
187 clear_interpreter_hooks ();
189 deprecated_show_load_progress
= mi_load_progress
;
195 mi_interpreter_suspend (void *data
)
197 gdb_disable_readline ();
201 static struct gdb_exception
202 mi_interpreter_exec (void *data
, const char *command
)
204 mi_execute_command_wrapper (command
);
205 return exception_none
;
209 mi_cmd_interpreter_exec (char *command
, char **argv
, int argc
)
211 struct interp
*interp_to_use
;
213 char *mi_error_message
= NULL
;
214 struct cleanup
*old_chain
;
217 error (_("-interpreter-exec: "
218 "Usage: -interpreter-exec interp command"));
220 interp_to_use
= interp_lookup (current_ui
, argv
[0]);
221 if (interp_to_use
== NULL
)
222 error (_("-interpreter-exec: could not find interpreter \"%s\""),
225 /* Note that unlike the CLI version of this command, we don't
226 actually set INTERP_TO_USE as the current interpreter, as we
227 still want gdb_stdout, etc. to point at MI streams. */
229 /* Insert the MI out hooks, making sure to also call the
230 interpreter's hooks if it has any. */
231 /* KRS: We shouldn't need this... Events should be installed and
232 they should just ALWAYS fire something out down the MI
234 mi_insert_notify_hooks ();
236 /* Now run the code. */
238 old_chain
= make_cleanup (null_cleanup
, 0);
239 for (i
= 1; i
< argc
; i
++)
241 struct gdb_exception e
= interp_exec (interp_to_use
, argv
[i
]);
245 mi_error_message
= xstrdup (e
.message
);
246 make_cleanup (xfree
, mi_error_message
);
251 mi_remove_notify_hooks ();
253 if (mi_error_message
!= NULL
)
254 error ("%s", mi_error_message
);
255 do_cleanups (old_chain
);
258 /* This inserts a number of hooks that are meant to produce
259 async-notify ("=") MI messages while running commands in another
260 interpreter using mi_interpreter_exec. The canonical use for this
261 is to allow access to the gdb CLI interpreter from within the MI,
262 while still producing MI style output when actions in the CLI
263 command change GDB's state. */
266 mi_insert_notify_hooks (void)
268 deprecated_query_hook
= mi_interp_query_hook
;
272 mi_remove_notify_hooks (void)
274 deprecated_query_hook
= NULL
;
278 mi_interp_query_hook (const char *ctlstr
, va_list ap
)
284 mi_execute_command_wrapper (const char *cmd
)
286 struct ui
*ui
= current_ui
;
288 mi_execute_command (cmd
, stdin
== ui
->instream
);
291 /* Observer for the synchronous_command_done notification. */
294 mi_on_sync_execution_done (void)
296 struct ui
*ui
= current_ui
;
297 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
302 /* If MI is sync, then output the MI prompt now, indicating we're
303 ready for further input. */
305 display_mi_prompt (mi
);
308 /* mi_execute_command_wrapper wrapper suitable for INPUT_HANDLER. */
311 mi_execute_command_input_handler (char *cmd
)
313 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
314 struct ui
*ui
= current_ui
;
316 ui
->prompt_state
= PROMPT_NEEDED
;
318 mi_execute_command_wrapper (cmd
);
320 /* Print a prompt, indicating we're ready for further input, unless
321 we just started a synchronous command. In that case, we're about
322 to go back to the event loop and will output the prompt in the
323 'synchronous_command_done' observer when the target next
325 if (ui
->prompt_state
== PROMPT_NEEDED
)
326 display_mi_prompt (mi
);
330 mi_interpreter_pre_command_loop (struct interp
*self
)
332 struct mi_interp
*mi
= (struct mi_interp
*) interp_data (self
);
334 /* Turn off 8 bit strings in quoted output. Any character with the
335 high bit set is printed using C's octal format. */
336 sevenbit_strings
= 1;
338 /* Tell the world that we're alive. */
339 display_mi_prompt (mi
);
343 mi_new_thread (struct thread_info
*t
)
345 struct inferior
*inf
= find_inferior_ptid (t
->ptid
);
346 struct switch_thru_all_uis state
;
350 SWITCH_THRU_ALL_UIS (state
)
352 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
353 struct cleanup
*old_chain
;
358 old_chain
= make_cleanup_restore_target_terminal ();
359 target_terminal_ours_for_output ();
361 fprintf_unfiltered (mi
->event_channel
,
362 "thread-created,id=\"%d\",group-id=\"i%d\"",
363 t
->global_num
, inf
->num
);
364 gdb_flush (mi
->event_channel
);
366 do_cleanups (old_chain
);
371 mi_thread_exit (struct thread_info
*t
, int silent
)
373 struct switch_thru_all_uis state
;
378 SWITCH_THRU_ALL_UIS (state
)
380 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
381 struct cleanup
*old_chain
;
386 old_chain
= make_cleanup_restore_target_terminal ();
387 target_terminal_ours_for_output ();
388 fprintf_unfiltered (mi
->event_channel
,
389 "thread-exited,id=\"%d\",group-id=\"i%d\"",
390 t
->global_num
, t
->inf
->num
);
391 gdb_flush (mi
->event_channel
);
393 do_cleanups (old_chain
);
397 /* Emit notification on changing the state of record. */
400 mi_record_changed (struct inferior
*inferior
, int started
, const char *method
,
403 struct switch_thru_all_uis state
;
405 SWITCH_THRU_ALL_UIS (state
)
407 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
408 struct cleanup
*old_chain
;
413 old_chain
= make_cleanup_restore_target_terminal ();
414 target_terminal_ours_for_output ();
420 fprintf_unfiltered (mi
->event_channel
,
421 "record-started,thread-group=\"i%d\","
422 "method=\"%s\",format=\"%s\"",
423 inferior
->num
, method
, format
);
427 fprintf_unfiltered (mi
->event_channel
,
428 "record-started,thread-group=\"i%d\","
430 inferior
->num
, method
);
435 fprintf_unfiltered (mi
->event_channel
,
436 "record-stopped,thread-group=\"i%d\"",
440 gdb_flush (mi
->event_channel
);
442 do_cleanups (old_chain
);
447 mi_inferior_added (struct inferior
*inf
)
449 struct switch_thru_all_uis state
;
451 SWITCH_THRU_ALL_UIS (state
)
453 struct interp
*interp
;
454 struct mi_interp
*mi
;
455 struct cleanup
*old_chain
;
457 /* We'll be called once for the initial inferior, before the top
458 level interpreter is set. */
459 interp
= top_level_interpreter ();
463 mi
= as_mi_interp (interp
);
467 old_chain
= make_cleanup_restore_target_terminal ();
468 target_terminal_ours_for_output ();
470 fprintf_unfiltered (mi
->event_channel
,
471 "thread-group-added,id=\"i%d\"",
473 gdb_flush (mi
->event_channel
);
475 do_cleanups (old_chain
);
480 mi_inferior_appeared (struct inferior
*inf
)
482 struct switch_thru_all_uis state
;
484 SWITCH_THRU_ALL_UIS (state
)
486 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
487 struct cleanup
*old_chain
;
492 old_chain
= make_cleanup_restore_target_terminal ();
493 target_terminal_ours_for_output ();
495 fprintf_unfiltered (mi
->event_channel
,
496 "thread-group-started,id=\"i%d\",pid=\"%d\"",
498 gdb_flush (mi
->event_channel
);
499 do_cleanups (old_chain
);
504 mi_inferior_exit (struct inferior
*inf
)
506 struct switch_thru_all_uis state
;
508 SWITCH_THRU_ALL_UIS (state
)
510 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
511 struct cleanup
*old_chain
;
516 old_chain
= make_cleanup_restore_target_terminal ();
517 target_terminal_ours_for_output ();
519 if (inf
->has_exit_code
)
520 fprintf_unfiltered (mi
->event_channel
,
521 "thread-group-exited,id=\"i%d\",exit-code=\"%s\"",
522 inf
->num
, int_string (inf
->exit_code
, 8, 0, 0, 1));
524 fprintf_unfiltered (mi
->event_channel
,
525 "thread-group-exited,id=\"i%d\"", inf
->num
);
527 gdb_flush (mi
->event_channel
);
528 do_cleanups (old_chain
);
533 mi_inferior_removed (struct inferior
*inf
)
535 struct switch_thru_all_uis state
;
537 SWITCH_THRU_ALL_UIS (state
)
539 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
540 struct cleanup
*old_chain
;
545 old_chain
= make_cleanup_restore_target_terminal ();
546 target_terminal_ours_for_output ();
548 fprintf_unfiltered (mi
->event_channel
,
549 "thread-group-removed,id=\"i%d\"",
551 gdb_flush (mi
->event_channel
);
553 do_cleanups (old_chain
);
557 /* Return the MI interpreter, if it is active -- either because it's
558 the top-level interpreter or the interpreter executing the current
559 command. Returns NULL if the MI interpreter is not being used. */
561 static struct mi_interp
*
562 find_mi_interp (void)
564 struct mi_interp
*mi
;
566 mi
= as_mi_interp (top_level_interpreter ());
570 mi
= as_mi_interp (command_interp ());
577 /* Observers for several run control events that print why the
578 inferior has stopped to both the the MI event channel and to the MI
579 console. If the MI interpreter is not active, print nothing. */
581 /* Observer for the signal_received notification. */
584 mi_on_signal_received (enum gdb_signal siggnal
)
586 struct switch_thru_all_uis state
;
588 SWITCH_THRU_ALL_UIS (state
)
590 struct mi_interp
*mi
= find_mi_interp ();
595 print_signal_received_reason (mi
->mi_uiout
, siggnal
);
596 print_signal_received_reason (mi
->cli_uiout
, siggnal
);
600 /* Observer for the end_stepping_range notification. */
603 mi_on_end_stepping_range (void)
605 struct switch_thru_all_uis state
;
607 SWITCH_THRU_ALL_UIS (state
)
609 struct mi_interp
*mi
= find_mi_interp ();
614 print_end_stepping_range_reason (mi
->mi_uiout
);
615 print_end_stepping_range_reason (mi
->cli_uiout
);
619 /* Observer for the signal_exited notification. */
622 mi_on_signal_exited (enum gdb_signal siggnal
)
624 struct switch_thru_all_uis state
;
626 SWITCH_THRU_ALL_UIS (state
)
628 struct mi_interp
*mi
= find_mi_interp ();
633 print_signal_exited_reason (mi
->mi_uiout
, siggnal
);
634 print_signal_exited_reason (mi
->cli_uiout
, siggnal
);
638 /* Observer for the exited notification. */
641 mi_on_exited (int exitstatus
)
643 struct switch_thru_all_uis state
;
645 SWITCH_THRU_ALL_UIS (state
)
647 struct mi_interp
*mi
= find_mi_interp ();
652 print_exited_reason (mi
->mi_uiout
, exitstatus
);
653 print_exited_reason (mi
->cli_uiout
, exitstatus
);
657 /* Observer for the no_history notification. */
660 mi_on_no_history (void)
662 struct switch_thru_all_uis state
;
664 SWITCH_THRU_ALL_UIS (state
)
666 struct mi_interp
*mi
= find_mi_interp ();
671 print_no_history_reason (mi
->mi_uiout
);
672 print_no_history_reason (mi
->cli_uiout
);
677 mi_on_normal_stop_1 (struct bpstats
*bs
, int print_frame
)
679 /* Since this can be called when CLI command is executing,
680 using cli interpreter, be sure to use MI uiout for output,
681 not the current one. */
682 struct ui_out
*mi_uiout
= interp_ui_out (top_level_interpreter ());
683 struct mi_interp
*mi
= (struct mi_interp
*) top_level_interpreter_data ();
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 ()))
725 print_stop_event (mi
->cli_uiout
);
727 tp
= inferior_thread ();
728 ui_out_field_int (mi_uiout
, "thread-id", tp
->global_num
);
731 struct cleanup
*back_to
= make_cleanup_ui_out_list_begin_end
732 (mi_uiout
, "stopped-threads");
734 ui_out_field_int (mi_uiout
, NULL
, tp
->global_num
);
735 do_cleanups (back_to
);
738 ui_out_field_string (mi_uiout
, "stopped-threads", "all");
740 core
= target_core_of_thread (inferior_ptid
);
742 ui_out_field_int (mi_uiout
, "core", core
);
745 fputs_unfiltered ("*stopped", mi
->raw_stdout
);
746 mi_out_put (mi_uiout
, mi
->raw_stdout
);
747 mi_out_rewind (mi_uiout
);
748 mi_print_timing_maybe (mi
->raw_stdout
);
749 fputs_unfiltered ("\n", mi
->raw_stdout
);
750 gdb_flush (mi
->raw_stdout
);
754 mi_on_normal_stop (struct bpstats
*bs
, int print_frame
)
756 struct switch_thru_all_uis state
;
758 SWITCH_THRU_ALL_UIS (state
)
760 if (as_mi_interp (top_level_interpreter ()) == NULL
)
763 mi_on_normal_stop_1 (bs
, print_frame
);
768 mi_about_to_proceed (void)
770 /* Suppress output while calling an inferior function. */
772 if (!ptid_equal (inferior_ptid
, null_ptid
))
774 struct thread_info
*tp
= inferior_thread ();
776 if (tp
->control
.in_infcall
)
783 /* When the element is non-zero, no MI notifications will be emitted in
784 response to the corresponding observers. */
786 struct mi_suppress_notification mi_suppress_notification
=
793 /* Emit notification on changing a traceframe. */
796 mi_traceframe_changed (int tfnum
, int tpnum
)
798 struct switch_thru_all_uis state
;
800 if (mi_suppress_notification
.traceframe
)
803 SWITCH_THRU_ALL_UIS (state
)
805 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
806 struct cleanup
*old_chain
;
811 old_chain
= make_cleanup_restore_target_terminal ();
812 target_terminal_ours_for_output ();
815 fprintf_unfiltered (mi
->event_channel
, "traceframe-changed,"
816 "num=\"%d\",tracepoint=\"%d\"\n",
819 fprintf_unfiltered (mi
->event_channel
, "traceframe-changed,end");
821 gdb_flush (mi
->event_channel
);
823 do_cleanups (old_chain
);
827 /* Emit notification on creating a trace state variable. */
830 mi_tsv_created (const struct trace_state_variable
*tsv
)
832 struct switch_thru_all_uis state
;
834 SWITCH_THRU_ALL_UIS (state
)
836 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
837 struct cleanup
*old_chain
;
842 old_chain
= make_cleanup_restore_target_terminal ();
843 target_terminal_ours_for_output ();
845 fprintf_unfiltered (mi
->event_channel
, "tsv-created,"
846 "name=\"%s\",initial=\"%s\"\n",
847 tsv
->name
, plongest (tsv
->initial_value
));
849 gdb_flush (mi
->event_channel
);
851 do_cleanups (old_chain
);
855 /* Emit notification on deleting a trace state variable. */
858 mi_tsv_deleted (const struct trace_state_variable
*tsv
)
860 struct switch_thru_all_uis state
;
862 SWITCH_THRU_ALL_UIS (state
)
864 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
865 struct cleanup
*old_chain
;
870 old_chain
= make_cleanup_restore_target_terminal ();
871 target_terminal_ours_for_output ();
874 fprintf_unfiltered (mi
->event_channel
, "tsv-deleted,"
875 "name=\"%s\"\n", tsv
->name
);
877 fprintf_unfiltered (mi
->event_channel
, "tsv-deleted\n");
879 gdb_flush (mi
->event_channel
);
881 do_cleanups (old_chain
);
885 /* Emit notification on modifying a trace state variable. */
888 mi_tsv_modified (const struct trace_state_variable
*tsv
)
890 struct switch_thru_all_uis state
;
892 SWITCH_THRU_ALL_UIS (state
)
894 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
895 struct ui_out
*mi_uiout
;
896 struct cleanup
*old_chain
;
901 mi_uiout
= interp_ui_out (top_level_interpreter ());
903 old_chain
= make_cleanup_restore_target_terminal ();
904 target_terminal_ours_for_output ();
906 fprintf_unfiltered (mi
->event_channel
,
909 ui_out_redirect (mi_uiout
, mi
->event_channel
);
911 ui_out_field_string (mi_uiout
, "name", tsv
->name
);
912 ui_out_field_string (mi_uiout
, "initial",
913 plongest (tsv
->initial_value
));
914 if (tsv
->value_known
)
915 ui_out_field_string (mi_uiout
, "current", plongest (tsv
->value
));
917 ui_out_redirect (mi_uiout
, NULL
);
919 gdb_flush (mi
->event_channel
);
921 do_cleanups (old_chain
);
925 /* Emit notification about a created breakpoint. */
928 mi_breakpoint_created (struct breakpoint
*b
)
930 struct switch_thru_all_uis state
;
932 if (mi_suppress_notification
.breakpoint
)
938 SWITCH_THRU_ALL_UIS (state
)
940 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
941 struct ui_out
*mi_uiout
;
942 struct cleanup
*old_chain
;
947 mi_uiout
= interp_ui_out (top_level_interpreter ());
949 old_chain
= make_cleanup_restore_target_terminal ();
950 target_terminal_ours_for_output ();
952 fprintf_unfiltered (mi
->event_channel
,
953 "breakpoint-created");
954 /* We want the output from gdb_breakpoint_query to go to
955 mi->event_channel. One approach would be to just call
956 gdb_breakpoint_query, and then use mi_out_put to send the current
957 content of mi_outout into mi->event_channel. However, that will
958 break if anything is output to mi_uiout prior to calling the
959 breakpoint_created notifications. So, we use
961 ui_out_redirect (mi_uiout
, mi
->event_channel
);
964 gdb_breakpoint_query (mi_uiout
, b
->number
, NULL
);
966 CATCH (e
, RETURN_MASK_ERROR
)
971 ui_out_redirect (mi_uiout
, NULL
);
973 gdb_flush (mi
->event_channel
);
975 do_cleanups (old_chain
);
979 /* Emit notification about deleted breakpoint. */
982 mi_breakpoint_deleted (struct breakpoint
*b
)
984 struct switch_thru_all_uis state
;
986 if (mi_suppress_notification
.breakpoint
)
992 SWITCH_THRU_ALL_UIS (state
)
994 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
995 struct cleanup
*old_chain
;
1000 old_chain
= make_cleanup_restore_target_terminal ();
1001 target_terminal_ours_for_output ();
1003 fprintf_unfiltered (mi
->event_channel
, "breakpoint-deleted,id=\"%d\"",
1006 gdb_flush (mi
->event_channel
);
1008 do_cleanups (old_chain
);
1012 /* Emit notification about modified breakpoint. */
1015 mi_breakpoint_modified (struct breakpoint
*b
)
1017 struct switch_thru_all_uis state
;
1019 if (mi_suppress_notification
.breakpoint
)
1025 SWITCH_THRU_ALL_UIS (state
)
1027 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1028 struct cleanup
*old_chain
;
1033 old_chain
= make_cleanup_restore_target_terminal ();
1034 target_terminal_ours_for_output ();
1035 fprintf_unfiltered (mi
->event_channel
,
1036 "breakpoint-modified");
1037 /* We want the output from gdb_breakpoint_query to go to
1038 mi->event_channel. One approach would be to just call
1039 gdb_breakpoint_query, and then use mi_out_put to send the current
1040 content of mi_outout into mi->event_channel. However, that will
1041 break if anything is output to mi_uiout prior to calling the
1042 breakpoint_created notifications. So, we use
1044 ui_out_redirect (mi
->mi_uiout
, mi
->event_channel
);
1047 gdb_breakpoint_query (mi
->mi_uiout
, b
->number
, NULL
);
1049 CATCH (e
, RETURN_MASK_ERROR
)
1054 ui_out_redirect (mi
->mi_uiout
, NULL
);
1056 gdb_flush (mi
->event_channel
);
1058 do_cleanups (old_chain
);
1063 mi_output_running_pid (struct thread_info
*info
, void *arg
)
1065 ptid_t
*ptid
= (ptid_t
*) arg
;
1066 struct switch_thru_all_uis state
;
1068 SWITCH_THRU_ALL_UIS (state
)
1070 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1075 if (ptid_get_pid (*ptid
) == ptid_get_pid (info
->ptid
))
1076 fprintf_unfiltered (mi
->raw_stdout
,
1077 "*running,thread-id=\"%d\"\n",
1085 mi_inferior_count (struct inferior
*inf
, void *arg
)
1089 int *count_p
= (int *) arg
;
1097 mi_on_resume_1 (struct mi_interp
*mi
, ptid_t ptid
)
1099 /* To cater for older frontends, emit ^running, but do it only once
1100 per each command. We do it here, since at this point we know
1101 that the target was successfully resumed, and in non-async mode,
1102 we won't return back to MI interpreter code until the target
1103 is done running, so delaying the output of "^running" until then
1104 will make it impossible for frontend to know what's going on.
1106 In future (MI3), we'll be outputting "^done" here. */
1107 if (!running_result_record_printed
&& mi_proceeded
)
1109 fprintf_unfiltered (mi
->raw_stdout
, "%s^running\n",
1110 current_token
? current_token
: "");
1113 if (ptid_get_pid (ptid
) == -1)
1114 fprintf_unfiltered (mi
->raw_stdout
, "*running,thread-id=\"all\"\n");
1115 else if (ptid_is_pid (ptid
))
1119 /* Backwards compatibility. If there's only one inferior,
1120 output "all", otherwise, output each resumed thread
1122 iterate_over_inferiors (mi_inferior_count
, &count
);
1125 fprintf_unfiltered (mi
->raw_stdout
, "*running,thread-id=\"all\"\n");
1127 iterate_over_threads (mi_output_running_pid
, &ptid
);
1131 struct thread_info
*ti
= find_thread_ptid (ptid
);
1134 fprintf_unfiltered (mi
->raw_stdout
, "*running,thread-id=\"%d\"\n",
1138 if (!running_result_record_printed
&& mi_proceeded
)
1140 running_result_record_printed
= 1;
1141 /* This is what gdb used to do historically -- printing prompt
1142 even if it cannot actually accept any input. This will be
1143 surely removed for MI3, and may be removed even earlier. */
1144 if (current_ui
->prompt_state
== PROMPT_BLOCKED
)
1145 fputs_unfiltered ("(gdb) \n", mi
->raw_stdout
);
1147 gdb_flush (mi
->raw_stdout
);
1151 mi_on_resume (ptid_t ptid
)
1153 struct thread_info
*tp
= NULL
;
1154 struct switch_thru_all_uis state
;
1156 if (ptid_equal (ptid
, minus_one_ptid
) || ptid_is_pid (ptid
))
1157 tp
= inferior_thread ();
1159 tp
= find_thread_ptid (ptid
);
1161 /* Suppress output while calling an inferior function. */
1162 if (tp
->control
.in_infcall
)
1165 SWITCH_THRU_ALL_UIS (state
)
1167 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1168 struct cleanup
*old_chain
;
1173 old_chain
= make_cleanup_restore_target_terminal ();
1174 target_terminal_ours_for_output ();
1176 mi_on_resume_1 (mi
, ptid
);
1178 do_cleanups (old_chain
);
1183 mi_solib_loaded (struct so_list
*solib
)
1185 struct switch_thru_all_uis state
;
1187 SWITCH_THRU_ALL_UIS (state
)
1189 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1190 struct ui_out
*uiout
;
1191 struct cleanup
*old_chain
;
1196 uiout
= interp_ui_out (top_level_interpreter ());
1198 old_chain
= make_cleanup_restore_target_terminal ();
1199 target_terminal_ours_for_output ();
1201 fprintf_unfiltered (mi
->event_channel
, "library-loaded");
1203 ui_out_redirect (uiout
, mi
->event_channel
);
1205 ui_out_field_string (uiout
, "id", solib
->so_original_name
);
1206 ui_out_field_string (uiout
, "target-name", solib
->so_original_name
);
1207 ui_out_field_string (uiout
, "host-name", solib
->so_name
);
1208 ui_out_field_int (uiout
, "symbols-loaded", solib
->symbols_loaded
);
1209 if (!gdbarch_has_global_solist (target_gdbarch ()))
1211 ui_out_field_fmt (uiout
, "thread-group", "i%d",
1212 current_inferior ()->num
);
1215 ui_out_redirect (uiout
, NULL
);
1217 gdb_flush (mi
->event_channel
);
1219 do_cleanups (old_chain
);
1224 mi_solib_unloaded (struct so_list
*solib
)
1226 struct switch_thru_all_uis state
;
1228 SWITCH_THRU_ALL_UIS (state
)
1230 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1231 struct ui_out
*uiout
;
1232 struct cleanup
*old_chain
;
1237 uiout
= interp_ui_out (top_level_interpreter ());
1239 old_chain
= make_cleanup_restore_target_terminal ();
1240 target_terminal_ours_for_output ();
1242 fprintf_unfiltered (mi
->event_channel
, "library-unloaded");
1244 ui_out_redirect (uiout
, mi
->event_channel
);
1246 ui_out_field_string (uiout
, "id", solib
->so_original_name
);
1247 ui_out_field_string (uiout
, "target-name", solib
->so_original_name
);
1248 ui_out_field_string (uiout
, "host-name", solib
->so_name
);
1249 if (!gdbarch_has_global_solist (target_gdbarch ()))
1251 ui_out_field_fmt (uiout
, "thread-group", "i%d",
1252 current_inferior ()->num
);
1255 ui_out_redirect (uiout
, NULL
);
1257 gdb_flush (mi
->event_channel
);
1259 do_cleanups (old_chain
);
1263 /* Emit notification about the command parameter change. */
1266 mi_command_param_changed (const char *param
, const char *value
)
1268 struct switch_thru_all_uis state
;
1270 if (mi_suppress_notification
.cmd_param_changed
)
1273 SWITCH_THRU_ALL_UIS (state
)
1275 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1276 struct ui_out
*mi_uiout
;
1277 struct cleanup
*old_chain
;
1282 mi_uiout
= interp_ui_out (top_level_interpreter ());
1284 old_chain
= make_cleanup_restore_target_terminal ();
1285 target_terminal_ours_for_output ();
1287 fprintf_unfiltered (mi
->event_channel
, "cmd-param-changed");
1289 ui_out_redirect (mi_uiout
, mi
->event_channel
);
1291 ui_out_field_string (mi_uiout
, "param", param
);
1292 ui_out_field_string (mi_uiout
, "value", value
);
1294 ui_out_redirect (mi_uiout
, NULL
);
1296 gdb_flush (mi
->event_channel
);
1298 do_cleanups (old_chain
);
1302 /* Emit notification about the target memory change. */
1305 mi_memory_changed (struct inferior
*inferior
, CORE_ADDR memaddr
,
1306 ssize_t len
, const bfd_byte
*myaddr
)
1308 struct switch_thru_all_uis state
;
1310 if (mi_suppress_notification
.memory
)
1313 SWITCH_THRU_ALL_UIS (state
)
1315 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1316 struct ui_out
*mi_uiout
;
1317 struct obj_section
*sec
;
1318 struct cleanup
*old_chain
;
1323 mi_uiout
= interp_ui_out (top_level_interpreter ());
1325 old_chain
= make_cleanup_restore_target_terminal ();
1326 target_terminal_ours_for_output ();
1328 fprintf_unfiltered (mi
->event_channel
, "memory-changed");
1330 ui_out_redirect (mi_uiout
, mi
->event_channel
);
1332 ui_out_field_fmt (mi_uiout
, "thread-group", "i%d", inferior
->num
);
1333 ui_out_field_core_addr (mi_uiout
, "addr", target_gdbarch (), memaddr
);
1334 ui_out_field_fmt (mi_uiout
, "len", "%s", hex_string (len
));
1336 /* Append 'type=code' into notification if MEMADDR falls in the range of
1337 sections contain code. */
1338 sec
= find_pc_section (memaddr
);
1339 if (sec
!= NULL
&& sec
->objfile
!= NULL
)
1341 flagword flags
= bfd_get_section_flags (sec
->objfile
->obfd
,
1342 sec
->the_bfd_section
);
1344 if (flags
& SEC_CODE
)
1345 ui_out_field_string (mi_uiout
, "type", "code");
1348 ui_out_redirect (mi_uiout
, NULL
);
1350 gdb_flush (mi
->event_channel
);
1352 do_cleanups (old_chain
);
1357 report_initial_inferior (struct inferior
*inf
, void *closure
)
1359 /* This function is called from mi_interpreter_init, and since
1360 mi_inferior_added assumes that inferior is fully initialized
1361 and top_level_interpreter_data is set, we cannot call
1363 struct mi_interp
*mi
= (struct mi_interp
*) closure
;
1364 struct cleanup
*old_chain
;
1366 old_chain
= make_cleanup_restore_target_terminal ();
1367 target_terminal_ours_for_output ();
1369 fprintf_unfiltered (mi
->event_channel
,
1370 "thread-group-added,id=\"i%d\"",
1372 gdb_flush (mi
->event_channel
);
1374 do_cleanups (old_chain
);
1378 static struct ui_out
*
1379 mi_ui_out (struct interp
*interp
)
1381 struct mi_interp
*mi
= (struct mi_interp
*) interp_data (interp
);
1383 return mi
->mi_uiout
;
1386 /* Do MI-specific logging actions; save raw_stdout, and change all
1387 the consoles to use the supplied ui-file(s). */
1390 mi_set_logging (struct interp
*interp
, int start_log
,
1391 struct ui_file
*out
, struct ui_file
*logfile
)
1393 struct mi_interp
*mi
= (struct mi_interp
*) interp_data (interp
);
1400 /* The tee created already is based on gdb_stdout, which for MI
1401 is a console and so we end up in an infinite loop of console
1402 writing to ui_file writing to console etc. So discard the
1403 existing tee (it hasn't been used yet, and MI won't ever use
1404 it), and create one based on raw_stdout instead. */
1407 ui_file_delete (out
);
1408 out
= tee_file_new (mi
->raw_stdout
, 0, logfile
, 0);
1411 mi
->saved_raw_stdout
= mi
->raw_stdout
;
1412 mi
->raw_stdout
= out
;
1416 mi
->raw_stdout
= mi
->saved_raw_stdout
;
1417 mi
->saved_raw_stdout
= NULL
;
1420 mi_console_set_raw (mi
->out
, mi
->raw_stdout
);
1421 mi_console_set_raw (mi
->err
, mi
->raw_stdout
);
1422 mi_console_set_raw (mi
->log
, mi
->raw_stdout
);
1423 mi_console_set_raw (mi
->targ
, mi
->raw_stdout
);
1424 mi_console_set_raw (mi
->event_channel
, mi
->raw_stdout
);
1429 /* The MI interpreter's vtable. */
1431 static const struct interp_procs mi_interp_procs
=
1433 mi_interpreter_init
, /* init_proc */
1434 mi_interpreter_resume
, /* resume_proc */
1435 mi_interpreter_suspend
, /* suspend_proc */
1436 mi_interpreter_exec
, /* exec_proc */
1437 mi_ui_out
, /* ui_out_proc */
1438 mi_set_logging
, /* set_logging_proc */
1439 mi_interpreter_pre_command_loop
/* pre_command_loop_proc */
1442 /* Factory for MI interpreters. */
1444 static struct interp
*
1445 mi_interp_factory (const char *name
)
1447 return interp_new (name
, &mi_interp_procs
, NULL
);
1450 extern initialize_file_ftype _initialize_mi_interp
; /* -Wmissing-prototypes */
1453 _initialize_mi_interp (void)
1455 /* The various interpreter levels. */
1456 interp_factory_register (INTERP_MI1
, mi_interp_factory
);
1457 interp_factory_register (INTERP_MI2
, mi_interp_factory
);
1458 interp_factory_register (INTERP_MI3
, mi_interp_factory
);
1459 interp_factory_register (INTERP_MI
, mi_interp_factory
);
1461 observer_attach_signal_received (mi_on_signal_received
);
1462 observer_attach_end_stepping_range (mi_on_end_stepping_range
);
1463 observer_attach_signal_exited (mi_on_signal_exited
);
1464 observer_attach_exited (mi_on_exited
);
1465 observer_attach_no_history (mi_on_no_history
);
1466 observer_attach_new_thread (mi_new_thread
);
1467 observer_attach_thread_exit (mi_thread_exit
);
1468 observer_attach_inferior_added (mi_inferior_added
);
1469 observer_attach_inferior_appeared (mi_inferior_appeared
);
1470 observer_attach_inferior_exit (mi_inferior_exit
);
1471 observer_attach_inferior_removed (mi_inferior_removed
);
1472 observer_attach_record_changed (mi_record_changed
);
1473 observer_attach_normal_stop (mi_on_normal_stop
);
1474 observer_attach_target_resumed (mi_on_resume
);
1475 observer_attach_solib_loaded (mi_solib_loaded
);
1476 observer_attach_solib_unloaded (mi_solib_unloaded
);
1477 observer_attach_about_to_proceed (mi_about_to_proceed
);
1478 observer_attach_traceframe_changed (mi_traceframe_changed
);
1479 observer_attach_tsv_created (mi_tsv_created
);
1480 observer_attach_tsv_deleted (mi_tsv_deleted
);
1481 observer_attach_tsv_modified (mi_tsv_modified
);
1482 observer_attach_breakpoint_created (mi_breakpoint_created
);
1483 observer_attach_breakpoint_deleted (mi_breakpoint_deleted
);
1484 observer_attach_breakpoint_modified (mi_breakpoint_modified
);
1485 observer_attach_command_param_changed (mi_command_param_changed
);
1486 observer_attach_memory_changed (mi_memory_changed
);
1487 observer_attach_sync_execution_done (mi_on_sync_execution_done
);