1 /* MI Interpreter Definitions and Commands for GDB, the GNU debugger.
3 Copyright (C) 2002-2017 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"
41 #include "cli/cli-interp.h"
43 /* These are the interpreter setup, etc. functions for the MI
46 static void mi_execute_command_wrapper (const char *cmd
);
47 static void mi_execute_command_input_handler (char *cmd
);
49 /* These are hooks that we put in place while doing interpreter_exec
50 so we can report interesting things that happened "behind the MI's
51 back" in this command. */
53 static int mi_interp_query_hook (const char *ctlstr
, va_list ap
)
54 ATTRIBUTE_PRINTF (1, 0);
56 static void mi_insert_notify_hooks (void);
57 static void mi_remove_notify_hooks (void);
59 static void mi_on_signal_received (enum gdb_signal siggnal
);
60 static void mi_on_end_stepping_range (void);
61 static void mi_on_signal_exited (enum gdb_signal siggnal
);
62 static void mi_on_exited (int exitstatus
);
63 static void mi_on_normal_stop (struct bpstats
*bs
, int print_frame
);
64 static void mi_on_no_history (void);
66 static void mi_new_thread (struct thread_info
*t
);
67 static void mi_thread_exit (struct thread_info
*t
, int silent
);
68 static void mi_record_changed (struct inferior
*, int, const char *,
70 static void mi_inferior_added (struct inferior
*inf
);
71 static void mi_inferior_appeared (struct inferior
*inf
);
72 static void mi_inferior_exit (struct inferior
*inf
);
73 static void mi_inferior_removed (struct inferior
*inf
);
74 static void mi_on_resume (ptid_t ptid
);
75 static void mi_solib_loaded (struct so_list
*solib
);
76 static void mi_solib_unloaded (struct so_list
*solib
);
77 static void mi_about_to_proceed (void);
78 static void mi_traceframe_changed (int tfnum
, int tpnum
);
79 static void mi_tsv_created (const struct trace_state_variable
*tsv
);
80 static void mi_tsv_deleted (const struct trace_state_variable
*tsv
);
81 static void mi_tsv_modified (const struct trace_state_variable
*tsv
);
82 static void mi_breakpoint_created (struct breakpoint
*b
);
83 static void mi_breakpoint_deleted (struct breakpoint
*b
);
84 static void mi_breakpoint_modified (struct breakpoint
*b
);
85 static void mi_command_param_changed (const char *param
, const char *value
);
86 static void mi_memory_changed (struct inferior
*inf
, CORE_ADDR memaddr
,
87 ssize_t len
, const bfd_byte
*myaddr
);
88 static void mi_on_sync_execution_done (void);
90 static int report_initial_inferior (struct inferior
*inf
, void *closure
);
92 /* Display the MI prompt. */
95 display_mi_prompt (struct mi_interp
*mi
)
97 struct ui
*ui
= current_ui
;
99 fputs_unfiltered ("(gdb) \n", mi
->raw_stdout
);
100 gdb_flush (mi
->raw_stdout
);
101 ui
->prompt_state
= PROMPTED
;
104 /* Returns the INTERP's data cast as mi_interp if INTERP is an MI, and
105 returns NULL otherwise. */
107 static struct mi_interp
*
108 as_mi_interp (struct interp
*interp
)
110 if (interp_ui_out (interp
)->is_mi_like_p ())
111 return (struct mi_interp
*) interp
;
116 mi_interp::init (bool top_level
)
118 mi_interp
*mi
= this;
122 /* Store the current output channel, so that we can create a console
123 channel that encapsulates and prefixes all gdb_output-type bits
124 coming from the rest of the debugger. */
125 mi
->raw_stdout
= gdb_stdout
;
127 /* Create MI console channels, each with a different prefix so they
128 can be distinguished. */
129 mi
->out
= new mi_console_file (mi
->raw_stdout
, "~", '"');
130 mi
->err
= new mi_console_file (mi
->raw_stdout
, "&", '"');
132 mi
->targ
= new mi_console_file (mi
->raw_stdout
, "@", '"');
133 mi
->event_channel
= new mi_console_file (mi
->raw_stdout
, "=", 0);
135 name
= interp_name (this);
136 /* INTERP_MI selects the most recent released version. "mi2" was
137 released as part of GDB 6.0. */
138 if (strcmp (name
, INTERP_MI
) == 0)
140 else if (strcmp (name
, INTERP_MI1
) == 0)
142 else if (strcmp (name
, INTERP_MI2
) == 0)
144 else if (strcmp (name
, INTERP_MI3
) == 0)
147 gdb_assert_not_reached ("unhandled MI version");
149 mi
->mi_uiout
= mi_out_new (mi_version
);
150 mi
->cli_uiout
= cli_out_new (mi
->out
);
154 /* The initial inferior is created before this function is
155 called, so we need to report it explicitly. Use iteration in
156 case future version of GDB creates more than one inferior
158 iterate_over_inferiors (report_initial_inferior
, mi
);
165 struct mi_interp
*mi
= this;
166 struct ui
*ui
= current_ui
;
168 /* As per hack note in mi_interpreter_init, swap in the output
170 gdb_setup_readline (0);
172 ui
->call_readline
= gdb_readline_no_editing_callback
;
173 ui
->input_handler
= mi_execute_command_input_handler
;
175 gdb_stdout
= mi
->out
;
176 /* Route error and log output through the MI. */
177 gdb_stderr
= mi
->err
;
178 gdb_stdlog
= mi
->log
;
179 /* Route target output through the MI. */
180 gdb_stdtarg
= mi
->targ
;
181 /* Route target error through the MI as well. */
182 gdb_stdtargerr
= mi
->targ
;
184 /* Replace all the hooks that we know about. There really needs to
185 be a better way of doing this... */
186 clear_interpreter_hooks ();
188 deprecated_show_load_progress
= mi_load_progress
;
192 mi_interp::suspend ()
194 gdb_disable_readline ();
198 mi_interp::exec (const char *command
)
200 mi_execute_command_wrapper (command
);
201 return exception_none
;
205 mi_cmd_interpreter_exec (const char *command
, char **argv
, int argc
)
207 struct interp
*interp_to_use
;
211 error (_("-interpreter-exec: "
212 "Usage: -interpreter-exec interp command"));
214 interp_to_use
= interp_lookup (current_ui
, argv
[0]);
215 if (interp_to_use
== NULL
)
216 error (_("-interpreter-exec: could not find interpreter \"%s\""),
219 /* Note that unlike the CLI version of this command, we don't
220 actually set INTERP_TO_USE as the current interpreter, as we
221 still want gdb_stdout, etc. to point at MI streams. */
223 /* Insert the MI out hooks, making sure to also call the
224 interpreter's hooks if it has any. */
225 /* KRS: We shouldn't need this... Events should be installed and
226 they should just ALWAYS fire something out down the MI
228 mi_insert_notify_hooks ();
230 /* Now run the code. */
232 std::string mi_error_message
;
233 for (i
= 1; i
< argc
; i
++)
235 struct gdb_exception e
= interp_exec (interp_to_use
, argv
[i
]);
239 mi_error_message
= e
.message
;
244 mi_remove_notify_hooks ();
246 if (!mi_error_message
.empty ())
247 error ("%s", mi_error_message
.c_str ());
250 /* This inserts a number of hooks that are meant to produce
251 async-notify ("=") MI messages while running commands in another
252 interpreter using mi_interpreter_exec. The canonical use for this
253 is to allow access to the gdb CLI interpreter from within the MI,
254 while still producing MI style output when actions in the CLI
255 command change GDB's state. */
258 mi_insert_notify_hooks (void)
260 deprecated_query_hook
= mi_interp_query_hook
;
264 mi_remove_notify_hooks (void)
266 deprecated_query_hook
= NULL
;
270 mi_interp_query_hook (const char *ctlstr
, va_list ap
)
276 mi_execute_command_wrapper (const char *cmd
)
278 struct ui
*ui
= current_ui
;
280 mi_execute_command (cmd
, ui
->instream
== ui
->stdin_stream
);
283 /* Observer for the synchronous_command_done notification. */
286 mi_on_sync_execution_done (void)
288 struct ui
*ui
= current_ui
;
289 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
294 /* If MI is sync, then output the MI prompt now, indicating we're
295 ready for further input. */
297 display_mi_prompt (mi
);
300 /* mi_execute_command_wrapper wrapper suitable for INPUT_HANDLER. */
303 mi_execute_command_input_handler (char *cmd
)
305 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
306 struct ui
*ui
= current_ui
;
308 ui
->prompt_state
= PROMPT_NEEDED
;
310 mi_execute_command_wrapper (cmd
);
312 /* Print a prompt, indicating we're ready for further input, unless
313 we just started a synchronous command. In that case, we're about
314 to go back to the event loop and will output the prompt in the
315 'synchronous_command_done' observer when the target next
317 if (ui
->prompt_state
== PROMPT_NEEDED
)
318 display_mi_prompt (mi
);
322 mi_interp::pre_command_loop ()
324 struct mi_interp
*mi
= this;
326 /* Turn off 8 bit strings in quoted output. Any character with the
327 high bit set is printed using C's octal format. */
328 sevenbit_strings
= 1;
330 /* Tell the world that we're alive. */
331 display_mi_prompt (mi
);
335 mi_new_thread (struct thread_info
*t
)
337 struct inferior
*inf
= find_inferior_ptid (t
->ptid
);
341 SWITCH_THRU_ALL_UIS ()
343 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
348 target_terminal::scoped_restore_terminal_state term_state
;
349 target_terminal::ours_for_output ();
351 fprintf_unfiltered (mi
->event_channel
,
352 "thread-created,id=\"%d\",group-id=\"i%d\"",
353 t
->global_num
, inf
->num
);
354 gdb_flush (mi
->event_channel
);
359 mi_thread_exit (struct thread_info
*t
, int silent
)
364 SWITCH_THRU_ALL_UIS ()
366 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
371 target_terminal::scoped_restore_terminal_state term_state
;
372 target_terminal::ours_for_output ();
373 fprintf_unfiltered (mi
->event_channel
,
374 "thread-exited,id=\"%d\",group-id=\"i%d\"",
375 t
->global_num
, t
->inf
->num
);
376 gdb_flush (mi
->event_channel
);
380 /* Emit notification on changing the state of record. */
383 mi_record_changed (struct inferior
*inferior
, int started
, const char *method
,
386 SWITCH_THRU_ALL_UIS ()
388 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
393 target_terminal::scoped_restore_terminal_state term_state
;
394 target_terminal::ours_for_output ();
400 fprintf_unfiltered (mi
->event_channel
,
401 "record-started,thread-group=\"i%d\","
402 "method=\"%s\",format=\"%s\"",
403 inferior
->num
, method
, format
);
407 fprintf_unfiltered (mi
->event_channel
,
408 "record-started,thread-group=\"i%d\","
410 inferior
->num
, method
);
415 fprintf_unfiltered (mi
->event_channel
,
416 "record-stopped,thread-group=\"i%d\"",
420 gdb_flush (mi
->event_channel
);
425 mi_inferior_added (struct inferior
*inf
)
427 SWITCH_THRU_ALL_UIS ()
429 struct interp
*interp
;
430 struct mi_interp
*mi
;
432 /* We'll be called once for the initial inferior, before the top
433 level interpreter is set. */
434 interp
= top_level_interpreter ();
438 mi
= as_mi_interp (interp
);
442 target_terminal::scoped_restore_terminal_state term_state
;
443 target_terminal::ours_for_output ();
445 fprintf_unfiltered (mi
->event_channel
,
446 "thread-group-added,id=\"i%d\"",
448 gdb_flush (mi
->event_channel
);
453 mi_inferior_appeared (struct inferior
*inf
)
455 SWITCH_THRU_ALL_UIS ()
457 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
462 target_terminal::scoped_restore_terminal_state term_state
;
463 target_terminal::ours_for_output ();
465 fprintf_unfiltered (mi
->event_channel
,
466 "thread-group-started,id=\"i%d\",pid=\"%d\"",
468 gdb_flush (mi
->event_channel
);
473 mi_inferior_exit (struct inferior
*inf
)
475 SWITCH_THRU_ALL_UIS ()
477 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
482 target_terminal::scoped_restore_terminal_state term_state
;
483 target_terminal::ours_for_output ();
485 if (inf
->has_exit_code
)
486 fprintf_unfiltered (mi
->event_channel
,
487 "thread-group-exited,id=\"i%d\",exit-code=\"%s\"",
488 inf
->num
, int_string (inf
->exit_code
, 8, 0, 0, 1));
490 fprintf_unfiltered (mi
->event_channel
,
491 "thread-group-exited,id=\"i%d\"", inf
->num
);
493 gdb_flush (mi
->event_channel
);
498 mi_inferior_removed (struct inferior
*inf
)
500 SWITCH_THRU_ALL_UIS ()
502 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
507 target_terminal::scoped_restore_terminal_state term_state
;
508 target_terminal::ours_for_output ();
510 fprintf_unfiltered (mi
->event_channel
,
511 "thread-group-removed,id=\"i%d\"",
513 gdb_flush (mi
->event_channel
);
517 /* Return the MI interpreter, if it is active -- either because it's
518 the top-level interpreter or the interpreter executing the current
519 command. Returns NULL if the MI interpreter is not being used. */
521 static struct mi_interp
*
522 find_mi_interp (void)
524 struct mi_interp
*mi
;
526 mi
= as_mi_interp (top_level_interpreter ());
530 mi
= as_mi_interp (command_interp ());
537 /* Observers for several run control events that print why the
538 inferior has stopped to both the the MI event channel and to the MI
539 console. If the MI interpreter is not active, print nothing. */
541 /* Observer for the signal_received notification. */
544 mi_on_signal_received (enum gdb_signal siggnal
)
546 SWITCH_THRU_ALL_UIS ()
548 struct mi_interp
*mi
= find_mi_interp ();
553 print_signal_received_reason (mi
->mi_uiout
, siggnal
);
554 print_signal_received_reason (mi
->cli_uiout
, siggnal
);
558 /* Observer for the end_stepping_range notification. */
561 mi_on_end_stepping_range (void)
563 SWITCH_THRU_ALL_UIS ()
565 struct mi_interp
*mi
= find_mi_interp ();
570 print_end_stepping_range_reason (mi
->mi_uiout
);
571 print_end_stepping_range_reason (mi
->cli_uiout
);
575 /* Observer for the signal_exited notification. */
578 mi_on_signal_exited (enum gdb_signal siggnal
)
580 SWITCH_THRU_ALL_UIS ()
582 struct mi_interp
*mi
= find_mi_interp ();
587 print_signal_exited_reason (mi
->mi_uiout
, siggnal
);
588 print_signal_exited_reason (mi
->cli_uiout
, siggnal
);
592 /* Observer for the exited notification. */
595 mi_on_exited (int exitstatus
)
597 SWITCH_THRU_ALL_UIS ()
599 struct mi_interp
*mi
= find_mi_interp ();
604 print_exited_reason (mi
->mi_uiout
, exitstatus
);
605 print_exited_reason (mi
->cli_uiout
, exitstatus
);
609 /* Observer for the no_history notification. */
612 mi_on_no_history (void)
614 SWITCH_THRU_ALL_UIS ()
616 struct mi_interp
*mi
= find_mi_interp ();
621 print_no_history_reason (mi
->mi_uiout
);
622 print_no_history_reason (mi
->cli_uiout
);
627 mi_on_normal_stop_1 (struct bpstats
*bs
, int print_frame
)
629 /* Since this can be called when CLI command is executing,
630 using cli interpreter, be sure to use MI uiout for output,
631 not the current one. */
632 struct ui_out
*mi_uiout
= interp_ui_out (top_level_interpreter ());
633 struct mi_interp
*mi
= (struct mi_interp
*) top_level_interpreter ();
637 struct thread_info
*tp
;
639 struct interp
*console_interp
;
641 tp
= inferior_thread ();
643 if (tp
->thread_fsm
!= NULL
644 && thread_fsm_finished_p (tp
->thread_fsm
))
646 enum async_reply_reason reason
;
648 reason
= thread_fsm_async_reply_reason (tp
->thread_fsm
);
649 mi_uiout
->field_string ("reason", async_reason_lookup (reason
));
651 print_stop_event (mi_uiout
);
653 console_interp
= interp_lookup (current_ui
, INTERP_CONSOLE
);
654 if (should_print_stop_to_console (console_interp
, tp
))
655 print_stop_event (mi
->cli_uiout
);
657 mi_uiout
->field_int ("thread-id", tp
->global_num
);
660 ui_out_emit_list
list_emitter (mi_uiout
, "stopped-threads");
662 mi_uiout
->field_int (NULL
, tp
->global_num
);
665 mi_uiout
->field_string ("stopped-threads", "all");
667 core
= target_core_of_thread (inferior_ptid
);
669 mi_uiout
->field_int ("core", core
);
672 fputs_unfiltered ("*stopped", mi
->raw_stdout
);
673 mi_out_put (mi_uiout
, mi
->raw_stdout
);
674 mi_out_rewind (mi_uiout
);
675 mi_print_timing_maybe (mi
->raw_stdout
);
676 fputs_unfiltered ("\n", mi
->raw_stdout
);
677 gdb_flush (mi
->raw_stdout
);
681 mi_on_normal_stop (struct bpstats
*bs
, int print_frame
)
683 SWITCH_THRU_ALL_UIS ()
685 if (as_mi_interp (top_level_interpreter ()) == NULL
)
688 mi_on_normal_stop_1 (bs
, print_frame
);
693 mi_about_to_proceed (void)
695 /* Suppress output while calling an inferior function. */
697 if (!ptid_equal (inferior_ptid
, null_ptid
))
699 struct thread_info
*tp
= inferior_thread ();
701 if (tp
->control
.in_infcall
)
708 /* When the element is non-zero, no MI notifications will be emitted in
709 response to the corresponding observers. */
711 struct mi_suppress_notification mi_suppress_notification
=
719 /* Emit notification on changing a traceframe. */
722 mi_traceframe_changed (int tfnum
, int tpnum
)
724 if (mi_suppress_notification
.traceframe
)
727 SWITCH_THRU_ALL_UIS ()
729 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
734 target_terminal::scoped_restore_terminal_state term_state
;
735 target_terminal::ours_for_output ();
738 fprintf_unfiltered (mi
->event_channel
, "traceframe-changed,"
739 "num=\"%d\",tracepoint=\"%d\"\n",
742 fprintf_unfiltered (mi
->event_channel
, "traceframe-changed,end");
744 gdb_flush (mi
->event_channel
);
748 /* Emit notification on creating a trace state variable. */
751 mi_tsv_created (const struct trace_state_variable
*tsv
)
753 SWITCH_THRU_ALL_UIS ()
755 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
760 target_terminal::scoped_restore_terminal_state term_state
;
761 target_terminal::ours_for_output ();
763 fprintf_unfiltered (mi
->event_channel
, "tsv-created,"
764 "name=\"%s\",initial=\"%s\"\n",
765 tsv
->name
, plongest (tsv
->initial_value
));
767 gdb_flush (mi
->event_channel
);
771 /* Emit notification on deleting a trace state variable. */
774 mi_tsv_deleted (const struct trace_state_variable
*tsv
)
776 SWITCH_THRU_ALL_UIS ()
778 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
783 target_terminal::scoped_restore_terminal_state term_state
;
784 target_terminal::ours_for_output ();
787 fprintf_unfiltered (mi
->event_channel
, "tsv-deleted,"
788 "name=\"%s\"\n", tsv
->name
);
790 fprintf_unfiltered (mi
->event_channel
, "tsv-deleted\n");
792 gdb_flush (mi
->event_channel
);
796 /* Emit notification on modifying a trace state variable. */
799 mi_tsv_modified (const struct trace_state_variable
*tsv
)
801 SWITCH_THRU_ALL_UIS ()
803 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
804 struct ui_out
*mi_uiout
;
809 mi_uiout
= interp_ui_out (top_level_interpreter ());
811 target_terminal::scoped_restore_terminal_state term_state
;
812 target_terminal::ours_for_output ();
814 fprintf_unfiltered (mi
->event_channel
,
817 mi_uiout
->redirect (mi
->event_channel
);
819 mi_uiout
->field_string ("name", tsv
->name
);
820 mi_uiout
->field_string ("initial",
821 plongest (tsv
->initial_value
));
822 if (tsv
->value_known
)
823 mi_uiout
->field_string ("current", plongest (tsv
->value
));
825 mi_uiout
->redirect (NULL
);
827 gdb_flush (mi
->event_channel
);
831 /* Emit notification about a created breakpoint. */
834 mi_breakpoint_created (struct breakpoint
*b
)
836 if (mi_suppress_notification
.breakpoint
)
842 SWITCH_THRU_ALL_UIS ()
844 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
845 struct ui_out
*mi_uiout
;
850 mi_uiout
= interp_ui_out (top_level_interpreter ());
852 target_terminal::scoped_restore_terminal_state term_state
;
853 target_terminal::ours_for_output ();
855 fprintf_unfiltered (mi
->event_channel
,
856 "breakpoint-created");
857 /* We want the output from gdb_breakpoint_query to go to
858 mi->event_channel. One approach would be to just call
859 gdb_breakpoint_query, and then use mi_out_put to send the current
860 content of mi_uiout into mi->event_channel. However, that will
861 break if anything is output to mi_uiout prior to calling the
862 breakpoint_created notifications. So, we use
864 mi_uiout
->redirect (mi
->event_channel
);
867 gdb_breakpoint_query (mi_uiout
, b
->number
, NULL
);
869 CATCH (e
, RETURN_MASK_ERROR
)
874 mi_uiout
->redirect (NULL
);
876 gdb_flush (mi
->event_channel
);
880 /* Emit notification about deleted breakpoint. */
883 mi_breakpoint_deleted (struct breakpoint
*b
)
885 if (mi_suppress_notification
.breakpoint
)
891 SWITCH_THRU_ALL_UIS ()
893 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
898 target_terminal::scoped_restore_terminal_state term_state
;
899 target_terminal::ours_for_output ();
901 fprintf_unfiltered (mi
->event_channel
, "breakpoint-deleted,id=\"%d\"",
904 gdb_flush (mi
->event_channel
);
908 /* Emit notification about modified breakpoint. */
911 mi_breakpoint_modified (struct breakpoint
*b
)
913 if (mi_suppress_notification
.breakpoint
)
919 SWITCH_THRU_ALL_UIS ()
921 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
926 target_terminal::scoped_restore_terminal_state term_state
;
927 target_terminal::ours_for_output ();
928 fprintf_unfiltered (mi
->event_channel
,
929 "breakpoint-modified");
930 /* We want the output from gdb_breakpoint_query to go to
931 mi->event_channel. One approach would be to just call
932 gdb_breakpoint_query, and then use mi_out_put to send the current
933 content of mi_uiout into mi->event_channel. However, that will
934 break if anything is output to mi_uiout prior to calling the
935 breakpoint_created notifications. So, we use
937 mi
->mi_uiout
->redirect (mi
->event_channel
);
940 gdb_breakpoint_query (mi
->mi_uiout
, b
->number
, NULL
);
942 CATCH (e
, RETURN_MASK_ERROR
)
947 mi
->mi_uiout
->redirect (NULL
);
949 gdb_flush (mi
->event_channel
);
954 mi_output_running_pid (struct thread_info
*info
, void *arg
)
956 ptid_t
*ptid
= (ptid_t
*) arg
;
958 SWITCH_THRU_ALL_UIS ()
960 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
965 if (ptid_get_pid (*ptid
) == ptid_get_pid (info
->ptid
))
966 fprintf_unfiltered (mi
->raw_stdout
,
967 "*running,thread-id=\"%d\"\n",
975 mi_inferior_count (struct inferior
*inf
, void *arg
)
979 int *count_p
= (int *) arg
;
987 mi_on_resume_1 (struct mi_interp
*mi
, ptid_t ptid
)
989 /* To cater for older frontends, emit ^running, but do it only once
990 per each command. We do it here, since at this point we know
991 that the target was successfully resumed, and in non-async mode,
992 we won't return back to MI interpreter code until the target
993 is done running, so delaying the output of "^running" until then
994 will make it impossible for frontend to know what's going on.
996 In future (MI3), we'll be outputting "^done" here. */
997 if (!running_result_record_printed
&& mi_proceeded
)
999 fprintf_unfiltered (mi
->raw_stdout
, "%s^running\n",
1000 current_token
? current_token
: "");
1003 if (ptid_get_pid (ptid
) == -1)
1004 fprintf_unfiltered (mi
->raw_stdout
, "*running,thread-id=\"all\"\n");
1005 else if (ptid_is_pid (ptid
))
1009 /* Backwards compatibility. If there's only one inferior,
1010 output "all", otherwise, output each resumed thread
1012 iterate_over_inferiors (mi_inferior_count
, &count
);
1015 fprintf_unfiltered (mi
->raw_stdout
, "*running,thread-id=\"all\"\n");
1017 iterate_over_threads (mi_output_running_pid
, &ptid
);
1021 struct thread_info
*ti
= find_thread_ptid (ptid
);
1024 fprintf_unfiltered (mi
->raw_stdout
, "*running,thread-id=\"%d\"\n",
1028 if (!running_result_record_printed
&& mi_proceeded
)
1030 running_result_record_printed
= 1;
1031 /* This is what gdb used to do historically -- printing prompt
1032 even if it cannot actually accept any input. This will be
1033 surely removed for MI3, and may be removed even earlier. */
1034 if (current_ui
->prompt_state
== PROMPT_BLOCKED
)
1035 fputs_unfiltered ("(gdb) \n", mi
->raw_stdout
);
1037 gdb_flush (mi
->raw_stdout
);
1041 mi_on_resume (ptid_t ptid
)
1043 struct thread_info
*tp
= NULL
;
1045 if (ptid_equal (ptid
, minus_one_ptid
) || ptid_is_pid (ptid
))
1046 tp
= inferior_thread ();
1048 tp
= find_thread_ptid (ptid
);
1050 /* Suppress output while calling an inferior function. */
1051 if (tp
->control
.in_infcall
)
1054 SWITCH_THRU_ALL_UIS ()
1056 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1061 target_terminal::scoped_restore_terminal_state term_state
;
1062 target_terminal::ours_for_output ();
1064 mi_on_resume_1 (mi
, ptid
);
1068 /* See mi-interp.h. */
1071 mi_output_solib_attribs (ui_out
*uiout
, struct so_list
*solib
)
1073 struct gdbarch
*gdbarch
= target_gdbarch ();
1075 uiout
->field_string ("id", solib
->so_original_name
);
1076 uiout
->field_string ("target-name", solib
->so_original_name
);
1077 uiout
->field_string ("host-name", solib
->so_name
);
1078 uiout
->field_int ("symbols-loaded", solib
->symbols_loaded
);
1079 if (!gdbarch_has_global_solist (target_gdbarch ()))
1080 uiout
->field_fmt ("thread-group", "i%d", current_inferior ()->num
);
1082 ui_out_emit_list
list_emitter (uiout
, "ranges");
1083 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1084 if (solib
->addr_high
!= 0)
1086 uiout
->field_core_addr ("from", gdbarch
, solib
->addr_low
);
1087 uiout
->field_core_addr ("to", gdbarch
, solib
->addr_high
);
1092 mi_solib_loaded (struct so_list
*solib
)
1094 SWITCH_THRU_ALL_UIS ()
1096 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1097 struct ui_out
*uiout
;
1102 uiout
= interp_ui_out (top_level_interpreter ());
1104 target_terminal::scoped_restore_terminal_state term_state
;
1105 target_terminal::ours_for_output ();
1107 fprintf_unfiltered (mi
->event_channel
, "library-loaded");
1109 uiout
->redirect (mi
->event_channel
);
1111 mi_output_solib_attribs (uiout
, solib
);
1113 uiout
->redirect (NULL
);
1115 gdb_flush (mi
->event_channel
);
1120 mi_solib_unloaded (struct so_list
*solib
)
1122 SWITCH_THRU_ALL_UIS ()
1124 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1125 struct ui_out
*uiout
;
1130 uiout
= interp_ui_out (top_level_interpreter ());
1132 target_terminal::scoped_restore_terminal_state term_state
;
1133 target_terminal::ours_for_output ();
1135 fprintf_unfiltered (mi
->event_channel
, "library-unloaded");
1137 uiout
->redirect (mi
->event_channel
);
1139 uiout
->field_string ("id", solib
->so_original_name
);
1140 uiout
->field_string ("target-name", solib
->so_original_name
);
1141 uiout
->field_string ("host-name", solib
->so_name
);
1142 if (!gdbarch_has_global_solist (target_gdbarch ()))
1144 uiout
->field_fmt ("thread-group", "i%d", current_inferior ()->num
);
1147 uiout
->redirect (NULL
);
1149 gdb_flush (mi
->event_channel
);
1153 /* Emit notification about the command parameter change. */
1156 mi_command_param_changed (const char *param
, const char *value
)
1158 if (mi_suppress_notification
.cmd_param_changed
)
1161 SWITCH_THRU_ALL_UIS ()
1163 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1164 struct ui_out
*mi_uiout
;
1169 mi_uiout
= interp_ui_out (top_level_interpreter ());
1171 target_terminal::scoped_restore_terminal_state term_state
;
1172 target_terminal::ours_for_output ();
1174 fprintf_unfiltered (mi
->event_channel
, "cmd-param-changed");
1176 mi_uiout
->redirect (mi
->event_channel
);
1178 mi_uiout
->field_string ("param", param
);
1179 mi_uiout
->field_string ("value", value
);
1181 mi_uiout
->redirect (NULL
);
1183 gdb_flush (mi
->event_channel
);
1187 /* Emit notification about the target memory change. */
1190 mi_memory_changed (struct inferior
*inferior
, CORE_ADDR memaddr
,
1191 ssize_t len
, const bfd_byte
*myaddr
)
1193 if (mi_suppress_notification
.memory
)
1196 SWITCH_THRU_ALL_UIS ()
1198 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1199 struct ui_out
*mi_uiout
;
1200 struct obj_section
*sec
;
1205 mi_uiout
= interp_ui_out (top_level_interpreter ());
1207 target_terminal::scoped_restore_terminal_state term_state
;
1208 target_terminal::ours_for_output ();
1210 fprintf_unfiltered (mi
->event_channel
, "memory-changed");
1212 mi_uiout
->redirect (mi
->event_channel
);
1214 mi_uiout
->field_fmt ("thread-group", "i%d", inferior
->num
);
1215 mi_uiout
->field_core_addr ("addr", target_gdbarch (), memaddr
);
1216 mi_uiout
->field_fmt ("len", "%s", hex_string (len
));
1218 /* Append 'type=code' into notification if MEMADDR falls in the range of
1219 sections contain code. */
1220 sec
= find_pc_section (memaddr
);
1221 if (sec
!= NULL
&& sec
->objfile
!= NULL
)
1223 flagword flags
= bfd_get_section_flags (sec
->objfile
->obfd
,
1224 sec
->the_bfd_section
);
1226 if (flags
& SEC_CODE
)
1227 mi_uiout
->field_string ("type", "code");
1230 mi_uiout
->redirect (NULL
);
1232 gdb_flush (mi
->event_channel
);
1236 /* Emit an event when the selection context (inferior, thread, frame)
1240 mi_user_selected_context_changed (user_selected_what selection
)
1242 struct thread_info
*tp
;
1244 /* Don't send an event if we're responding to an MI command. */
1245 if (mi_suppress_notification
.user_selected_context
)
1248 tp
= find_thread_ptid (inferior_ptid
);
1250 SWITCH_THRU_ALL_UIS ()
1252 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1253 struct ui_out
*mi_uiout
;
1258 mi_uiout
= interp_ui_out (top_level_interpreter ());
1260 mi_uiout
->redirect (mi
->event_channel
);
1261 ui_out_redirect_pop
redirect_popper (mi_uiout
);
1263 target_terminal::scoped_restore_terminal_state term_state
;
1264 target_terminal::ours_for_output ();
1266 if (selection
& USER_SELECTED_INFERIOR
)
1267 print_selected_inferior (mi
->cli_uiout
);
1270 && (selection
& (USER_SELECTED_THREAD
| USER_SELECTED_FRAME
)))
1272 print_selected_thread_frame (mi
->cli_uiout
, selection
);
1274 fprintf_unfiltered (mi
->event_channel
,
1275 "thread-selected,id=\"%d\"",
1278 if (tp
->state
!= THREAD_RUNNING
)
1280 if (has_stack_frames ())
1281 print_stack_frame_to_uiout (mi_uiout
, get_selected_frame (NULL
),
1286 gdb_flush (mi
->event_channel
);
1291 report_initial_inferior (struct inferior
*inf
, void *closure
)
1293 /* This function is called from mi_interpreter_init, and since
1294 mi_inferior_added assumes that inferior is fully initialized
1295 and top_level_interpreter_data is set, we cannot call
1297 struct mi_interp
*mi
= (struct mi_interp
*) closure
;
1299 target_terminal::scoped_restore_terminal_state term_state
;
1300 target_terminal::ours_for_output ();
1302 fprintf_unfiltered (mi
->event_channel
,
1303 "thread-group-added,id=\"i%d\"",
1305 gdb_flush (mi
->event_channel
);
1311 mi_interp::interp_ui_out ()
1313 return this->mi_uiout
;
1316 /* Do MI-specific logging actions; save raw_stdout, and change all
1317 the consoles to use the supplied ui-file(s). */
1320 mi_interp::set_logging (ui_file_up logfile
, bool logging_redirect
)
1322 struct mi_interp
*mi
= this;
1324 if (logfile
!= NULL
)
1326 mi
->saved_raw_stdout
= mi
->raw_stdout
;
1327 mi
->raw_stdout
= make_logging_output (mi
->raw_stdout
,
1328 std::move (logfile
),
1334 delete mi
->raw_stdout
;
1335 mi
->raw_stdout
= mi
->saved_raw_stdout
;
1336 mi
->saved_raw_stdout
= NULL
;
1339 mi
->out
->set_raw (mi
->raw_stdout
);
1340 mi
->err
->set_raw (mi
->raw_stdout
);
1341 mi
->log
->set_raw (mi
->raw_stdout
);
1342 mi
->targ
->set_raw (mi
->raw_stdout
);
1343 mi
->event_channel
->set_raw (mi
->raw_stdout
);
1346 /* Factory for MI interpreters. */
1348 static struct interp
*
1349 mi_interp_factory (const char *name
)
1351 return new mi_interp (name
);
1355 _initialize_mi_interp (void)
1357 /* The various interpreter levels. */
1358 interp_factory_register (INTERP_MI1
, mi_interp_factory
);
1359 interp_factory_register (INTERP_MI2
, mi_interp_factory
);
1360 interp_factory_register (INTERP_MI3
, mi_interp_factory
);
1361 interp_factory_register (INTERP_MI
, mi_interp_factory
);
1363 observer_attach_signal_received (mi_on_signal_received
);
1364 observer_attach_end_stepping_range (mi_on_end_stepping_range
);
1365 observer_attach_signal_exited (mi_on_signal_exited
);
1366 observer_attach_exited (mi_on_exited
);
1367 observer_attach_no_history (mi_on_no_history
);
1368 observer_attach_new_thread (mi_new_thread
);
1369 observer_attach_thread_exit (mi_thread_exit
);
1370 observer_attach_inferior_added (mi_inferior_added
);
1371 observer_attach_inferior_appeared (mi_inferior_appeared
);
1372 observer_attach_inferior_exit (mi_inferior_exit
);
1373 observer_attach_inferior_removed (mi_inferior_removed
);
1374 observer_attach_record_changed (mi_record_changed
);
1375 observer_attach_normal_stop (mi_on_normal_stop
);
1376 observer_attach_target_resumed (mi_on_resume
);
1377 observer_attach_solib_loaded (mi_solib_loaded
);
1378 observer_attach_solib_unloaded (mi_solib_unloaded
);
1379 observer_attach_about_to_proceed (mi_about_to_proceed
);
1380 observer_attach_traceframe_changed (mi_traceframe_changed
);
1381 observer_attach_tsv_created (mi_tsv_created
);
1382 observer_attach_tsv_deleted (mi_tsv_deleted
);
1383 observer_attach_tsv_modified (mi_tsv_modified
);
1384 observer_attach_breakpoint_created (mi_breakpoint_created
);
1385 observer_attach_breakpoint_deleted (mi_breakpoint_deleted
);
1386 observer_attach_breakpoint_modified (mi_breakpoint_modified
);
1387 observer_attach_command_param_changed (mi_command_param_changed
);
1388 observer_attach_memory_changed (mi_memory_changed
);
1389 observer_attach_sync_execution_done (mi_on_sync_execution_done
);
1390 observer_attach_user_selected_context_changed
1391 (mi_user_selected_context_changed
);