1 /* MI Interpreter Definitions and Commands for GDB, the GNU debugger.
3 Copyright (C) 2002-2018 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"
33 #include "observable.h"
34 #include "gdbthread.h"
37 #include "tracepoint.h"
39 #include "thread-fsm.h"
40 #include "cli/cli-interp.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 (interp_ui_out (interp
)->is_mi_like_p ())
110 return (struct mi_interp
*) interp
;
115 mi_interp::init (bool top_level
)
117 mi_interp
*mi
= this;
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
= new mi_console_file (mi
->raw_stdout
, "~", '"');
129 mi
->err
= new mi_console_file (mi
->raw_stdout
, "&", '"');
131 mi
->targ
= new mi_console_file (mi
->raw_stdout
, "@", '"');
132 mi
->event_channel
= new mi_console_file (mi
->raw_stdout
, "=", 0);
134 name
= interp_name (this);
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 struct mi_interp
*mi
= this;
165 struct ui
*ui
= current_ui
;
167 /* As per hack note in mi_interpreter_init, swap in the output
169 gdb_setup_readline (0);
171 ui
->call_readline
= gdb_readline_no_editing_callback
;
172 ui
->input_handler
= mi_execute_command_input_handler
;
174 gdb_stdout
= mi
->out
;
175 /* Route error and log output through the MI. */
176 gdb_stderr
= mi
->err
;
177 gdb_stdlog
= mi
->log
;
178 /* Route target output through the MI. */
179 gdb_stdtarg
= mi
->targ
;
180 /* Route target error through the MI as well. */
181 gdb_stdtargerr
= mi
->targ
;
183 /* Replace all the hooks that we know about. There really needs to
184 be a better way of doing this... */
185 clear_interpreter_hooks ();
187 deprecated_show_load_progress
= mi_load_progress
;
191 mi_interp::suspend ()
193 gdb_disable_readline ();
197 mi_interp::exec (const char *command
)
199 mi_execute_command_wrapper (command
);
200 return exception_none
;
204 mi_cmd_interpreter_exec (const char *command
, char **argv
, int argc
)
206 struct interp
*interp_to_use
;
210 error (_("-interpreter-exec: "
211 "Usage: -interpreter-exec interp command"));
213 interp_to_use
= interp_lookup (current_ui
, argv
[0]);
214 if (interp_to_use
== NULL
)
215 error (_("-interpreter-exec: could not find interpreter \"%s\""),
218 /* Note that unlike the CLI version of this command, we don't
219 actually set INTERP_TO_USE as the current interpreter, as we
220 still want gdb_stdout, etc. to point at MI streams. */
222 /* Insert the MI out hooks, making sure to also call the
223 interpreter's hooks if it has any. */
224 /* KRS: We shouldn't need this... Events should be installed and
225 they should just ALWAYS fire something out down the MI
227 mi_insert_notify_hooks ();
229 /* Now run the code. */
231 std::string mi_error_message
;
232 for (i
= 1; i
< argc
; i
++)
234 struct gdb_exception e
= interp_exec (interp_to_use
, argv
[i
]);
238 mi_error_message
= e
.message
;
243 mi_remove_notify_hooks ();
245 if (!mi_error_message
.empty ())
246 error ("%s", mi_error_message
.c_str ());
249 /* This inserts a number of hooks that are meant to produce
250 async-notify ("=") MI messages while running commands in another
251 interpreter using mi_interpreter_exec. The canonical use for this
252 is to allow access to the gdb CLI interpreter from within the MI,
253 while still producing MI style output when actions in the CLI
254 command change GDB's state. */
257 mi_insert_notify_hooks (void)
259 deprecated_query_hook
= mi_interp_query_hook
;
263 mi_remove_notify_hooks (void)
265 deprecated_query_hook
= NULL
;
269 mi_interp_query_hook (const char *ctlstr
, va_list ap
)
275 mi_execute_command_wrapper (const char *cmd
)
277 struct ui
*ui
= current_ui
;
279 mi_execute_command (cmd
, ui
->instream
== ui
->stdin_stream
);
282 /* Observer for the synchronous_command_done notification. */
285 mi_on_sync_execution_done (void)
287 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
292 /* If MI is sync, then output the MI prompt now, indicating we're
293 ready for further input. */
295 display_mi_prompt (mi
);
298 /* mi_execute_command_wrapper wrapper suitable for INPUT_HANDLER. */
301 mi_execute_command_input_handler (char *cmd
)
303 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
304 struct ui
*ui
= current_ui
;
306 ui
->prompt_state
= PROMPT_NEEDED
;
308 mi_execute_command_wrapper (cmd
);
310 /* Print a prompt, indicating we're ready for further input, unless
311 we just started a synchronous command. In that case, we're about
312 to go back to the event loop and will output the prompt in the
313 'synchronous_command_done' observer when the target next
315 if (ui
->prompt_state
== PROMPT_NEEDED
)
316 display_mi_prompt (mi
);
320 mi_interp::pre_command_loop ()
322 struct mi_interp
*mi
= this;
324 /* Turn off 8 bit strings in quoted output. Any character with the
325 high bit set is printed using C's octal format. */
326 sevenbit_strings
= 1;
328 /* Tell the world that we're alive. */
329 display_mi_prompt (mi
);
333 mi_new_thread (struct thread_info
*t
)
335 struct inferior
*inf
= find_inferior_ptid (t
->ptid
);
339 SWITCH_THRU_ALL_UIS ()
341 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
346 target_terminal::scoped_restore_terminal_state term_state
;
347 target_terminal::ours_for_output ();
349 fprintf_unfiltered (mi
->event_channel
,
350 "thread-created,id=\"%d\",group-id=\"i%d\"",
351 t
->global_num
, inf
->num
);
352 gdb_flush (mi
->event_channel
);
357 mi_thread_exit (struct thread_info
*t
, int silent
)
362 SWITCH_THRU_ALL_UIS ()
364 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
369 target_terminal::scoped_restore_terminal_state term_state
;
370 target_terminal::ours_for_output ();
371 fprintf_unfiltered (mi
->event_channel
,
372 "thread-exited,id=\"%d\",group-id=\"i%d\"",
373 t
->global_num
, t
->inf
->num
);
374 gdb_flush (mi
->event_channel
);
378 /* Emit notification on changing the state of record. */
381 mi_record_changed (struct inferior
*inferior
, int started
, const char *method
,
384 SWITCH_THRU_ALL_UIS ()
386 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
391 target_terminal::scoped_restore_terminal_state term_state
;
392 target_terminal::ours_for_output ();
398 fprintf_unfiltered (mi
->event_channel
,
399 "record-started,thread-group=\"i%d\","
400 "method=\"%s\",format=\"%s\"",
401 inferior
->num
, method
, format
);
405 fprintf_unfiltered (mi
->event_channel
,
406 "record-started,thread-group=\"i%d\","
408 inferior
->num
, method
);
413 fprintf_unfiltered (mi
->event_channel
,
414 "record-stopped,thread-group=\"i%d\"",
418 gdb_flush (mi
->event_channel
);
423 mi_inferior_added (struct inferior
*inf
)
425 SWITCH_THRU_ALL_UIS ()
427 struct interp
*interp
;
428 struct mi_interp
*mi
;
430 /* We'll be called once for the initial inferior, before the top
431 level interpreter is set. */
432 interp
= top_level_interpreter ();
436 mi
= as_mi_interp (interp
);
440 target_terminal::scoped_restore_terminal_state term_state
;
441 target_terminal::ours_for_output ();
443 fprintf_unfiltered (mi
->event_channel
,
444 "thread-group-added,id=\"i%d\"",
446 gdb_flush (mi
->event_channel
);
451 mi_inferior_appeared (struct inferior
*inf
)
453 SWITCH_THRU_ALL_UIS ()
455 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
460 target_terminal::scoped_restore_terminal_state term_state
;
461 target_terminal::ours_for_output ();
463 fprintf_unfiltered (mi
->event_channel
,
464 "thread-group-started,id=\"i%d\",pid=\"%d\"",
466 gdb_flush (mi
->event_channel
);
471 mi_inferior_exit (struct inferior
*inf
)
473 SWITCH_THRU_ALL_UIS ()
475 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
480 target_terminal::scoped_restore_terminal_state term_state
;
481 target_terminal::ours_for_output ();
483 if (inf
->has_exit_code
)
484 fprintf_unfiltered (mi
->event_channel
,
485 "thread-group-exited,id=\"i%d\",exit-code=\"%s\"",
486 inf
->num
, int_string (inf
->exit_code
, 8, 0, 0, 1));
488 fprintf_unfiltered (mi
->event_channel
,
489 "thread-group-exited,id=\"i%d\"", inf
->num
);
491 gdb_flush (mi
->event_channel
);
496 mi_inferior_removed (struct inferior
*inf
)
498 SWITCH_THRU_ALL_UIS ()
500 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
505 target_terminal::scoped_restore_terminal_state term_state
;
506 target_terminal::ours_for_output ();
508 fprintf_unfiltered (mi
->event_channel
,
509 "thread-group-removed,id=\"i%d\"",
511 gdb_flush (mi
->event_channel
);
515 /* Return the MI interpreter, if it is active -- either because it's
516 the top-level interpreter or the interpreter executing the current
517 command. Returns NULL if the MI interpreter is not being used. */
519 static struct mi_interp
*
520 find_mi_interp (void)
522 struct mi_interp
*mi
;
524 mi
= as_mi_interp (top_level_interpreter ());
528 mi
= as_mi_interp (command_interp ());
535 /* Observers for several run control events that print why the
536 inferior has stopped to both the the MI event channel and to the MI
537 console. If the MI interpreter is not active, print nothing. */
539 /* Observer for the signal_received notification. */
542 mi_on_signal_received (enum gdb_signal siggnal
)
544 SWITCH_THRU_ALL_UIS ()
546 struct mi_interp
*mi
= find_mi_interp ();
551 print_signal_received_reason (mi
->mi_uiout
, siggnal
);
552 print_signal_received_reason (mi
->cli_uiout
, siggnal
);
556 /* Observer for the end_stepping_range notification. */
559 mi_on_end_stepping_range (void)
561 SWITCH_THRU_ALL_UIS ()
563 struct mi_interp
*mi
= find_mi_interp ();
568 print_end_stepping_range_reason (mi
->mi_uiout
);
569 print_end_stepping_range_reason (mi
->cli_uiout
);
573 /* Observer for the signal_exited notification. */
576 mi_on_signal_exited (enum gdb_signal siggnal
)
578 SWITCH_THRU_ALL_UIS ()
580 struct mi_interp
*mi
= find_mi_interp ();
585 print_signal_exited_reason (mi
->mi_uiout
, siggnal
);
586 print_signal_exited_reason (mi
->cli_uiout
, siggnal
);
590 /* Observer for the exited notification. */
593 mi_on_exited (int exitstatus
)
595 SWITCH_THRU_ALL_UIS ()
597 struct mi_interp
*mi
= find_mi_interp ();
602 print_exited_reason (mi
->mi_uiout
, exitstatus
);
603 print_exited_reason (mi
->cli_uiout
, exitstatus
);
607 /* Observer for the no_history notification. */
610 mi_on_no_history (void)
612 SWITCH_THRU_ALL_UIS ()
614 struct mi_interp
*mi
= find_mi_interp ();
619 print_no_history_reason (mi
->mi_uiout
);
620 print_no_history_reason (mi
->cli_uiout
);
625 mi_on_normal_stop_1 (struct bpstats
*bs
, int print_frame
)
627 /* Since this can be called when CLI command is executing,
628 using cli interpreter, be sure to use MI uiout for output,
629 not the current one. */
630 struct ui_out
*mi_uiout
= interp_ui_out (top_level_interpreter ());
631 struct mi_interp
*mi
= (struct mi_interp
*) top_level_interpreter ();
635 struct thread_info
*tp
;
637 struct interp
*console_interp
;
639 tp
= inferior_thread ();
641 if (tp
->thread_fsm
!= NULL
642 && thread_fsm_finished_p (tp
->thread_fsm
))
644 enum async_reply_reason reason
;
646 reason
= thread_fsm_async_reply_reason (tp
->thread_fsm
);
647 mi_uiout
->field_string ("reason", async_reason_lookup (reason
));
649 print_stop_event (mi_uiout
);
651 console_interp
= interp_lookup (current_ui
, INTERP_CONSOLE
);
652 if (should_print_stop_to_console (console_interp
, tp
))
653 print_stop_event (mi
->cli_uiout
);
655 mi_uiout
->field_int ("thread-id", tp
->global_num
);
658 ui_out_emit_list
list_emitter (mi_uiout
, "stopped-threads");
660 mi_uiout
->field_int (NULL
, tp
->global_num
);
663 mi_uiout
->field_string ("stopped-threads", "all");
665 core
= target_core_of_thread (inferior_ptid
);
667 mi_uiout
->field_int ("core", core
);
670 fputs_unfiltered ("*stopped", mi
->raw_stdout
);
671 mi_out_put (mi_uiout
, mi
->raw_stdout
);
672 mi_out_rewind (mi_uiout
);
673 mi_print_timing_maybe (mi
->raw_stdout
);
674 fputs_unfiltered ("\n", mi
->raw_stdout
);
675 gdb_flush (mi
->raw_stdout
);
679 mi_on_normal_stop (struct bpstats
*bs
, int print_frame
)
681 SWITCH_THRU_ALL_UIS ()
683 if (as_mi_interp (top_level_interpreter ()) == NULL
)
686 mi_on_normal_stop_1 (bs
, print_frame
);
691 mi_about_to_proceed (void)
693 /* Suppress output while calling an inferior function. */
695 if (!ptid_equal (inferior_ptid
, null_ptid
))
697 struct thread_info
*tp
= inferior_thread ();
699 if (tp
->control
.in_infcall
)
706 /* When the element is non-zero, no MI notifications will be emitted in
707 response to the corresponding observers. */
709 struct mi_suppress_notification mi_suppress_notification
=
717 /* Emit notification on changing a traceframe. */
720 mi_traceframe_changed (int tfnum
, int tpnum
)
722 if (mi_suppress_notification
.traceframe
)
725 SWITCH_THRU_ALL_UIS ()
727 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
732 target_terminal::scoped_restore_terminal_state term_state
;
733 target_terminal::ours_for_output ();
736 fprintf_unfiltered (mi
->event_channel
, "traceframe-changed,"
737 "num=\"%d\",tracepoint=\"%d\"\n",
740 fprintf_unfiltered (mi
->event_channel
, "traceframe-changed,end");
742 gdb_flush (mi
->event_channel
);
746 /* Emit notification on creating a trace state variable. */
749 mi_tsv_created (const struct trace_state_variable
*tsv
)
751 SWITCH_THRU_ALL_UIS ()
753 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
758 target_terminal::scoped_restore_terminal_state term_state
;
759 target_terminal::ours_for_output ();
761 fprintf_unfiltered (mi
->event_channel
, "tsv-created,"
762 "name=\"%s\",initial=\"%s\"\n",
763 tsv
->name
.c_str (), plongest (tsv
->initial_value
));
765 gdb_flush (mi
->event_channel
);
769 /* Emit notification on deleting a trace state variable. */
772 mi_tsv_deleted (const struct trace_state_variable
*tsv
)
774 SWITCH_THRU_ALL_UIS ()
776 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
781 target_terminal::scoped_restore_terminal_state term_state
;
782 target_terminal::ours_for_output ();
785 fprintf_unfiltered (mi
->event_channel
, "tsv-deleted,"
786 "name=\"%s\"\n", tsv
->name
.c_str ());
788 fprintf_unfiltered (mi
->event_channel
, "tsv-deleted\n");
790 gdb_flush (mi
->event_channel
);
794 /* Emit notification on modifying a trace state variable. */
797 mi_tsv_modified (const struct trace_state_variable
*tsv
)
799 SWITCH_THRU_ALL_UIS ()
801 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
802 struct ui_out
*mi_uiout
;
807 mi_uiout
= interp_ui_out (top_level_interpreter ());
809 target_terminal::scoped_restore_terminal_state term_state
;
810 target_terminal::ours_for_output ();
812 fprintf_unfiltered (mi
->event_channel
,
815 mi_uiout
->redirect (mi
->event_channel
);
817 mi_uiout
->field_string ("name", tsv
->name
);
818 mi_uiout
->field_string ("initial",
819 plongest (tsv
->initial_value
));
820 if (tsv
->value_known
)
821 mi_uiout
->field_string ("current", plongest (tsv
->value
));
823 mi_uiout
->redirect (NULL
);
825 gdb_flush (mi
->event_channel
);
829 /* Print breakpoint BP on MI's event channel. */
832 mi_print_breakpoint_for_event (struct mi_interp
*mi
, breakpoint
*bp
)
834 ui_out
*mi_uiout
= interp_ui_out (mi
);
836 /* We want the output from print_breakpoint to go to
837 mi->event_channel. One approach would be to just call
838 print_breakpoint, and then use mi_out_put to send the current
839 content of mi_uiout into mi->event_channel. However, that will
840 break if anything is output to mi_uiout prior to calling the
841 breakpoint_created notifications. So, we use
843 mi_uiout
->redirect (mi
->event_channel
);
847 scoped_restore restore_uiout
848 = make_scoped_restore (¤t_uiout
, mi_uiout
);
850 print_breakpoint (bp
);
852 CATCH (ex
, RETURN_MASK_ALL
)
854 exception_print (gdb_stderr
, ex
);
858 mi_uiout
->redirect (NULL
);
861 /* Emit notification about a created breakpoint. */
864 mi_breakpoint_created (struct breakpoint
*b
)
866 if (mi_suppress_notification
.breakpoint
)
872 SWITCH_THRU_ALL_UIS ()
874 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
879 target_terminal::scoped_restore_terminal_state term_state
;
880 target_terminal::ours_for_output ();
882 fprintf_unfiltered (mi
->event_channel
,
883 "breakpoint-created");
884 mi_print_breakpoint_for_event (mi
, b
);
886 gdb_flush (mi
->event_channel
);
890 /* Emit notification about deleted breakpoint. */
893 mi_breakpoint_deleted (struct breakpoint
*b
)
895 if (mi_suppress_notification
.breakpoint
)
901 SWITCH_THRU_ALL_UIS ()
903 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
908 target_terminal::scoped_restore_terminal_state term_state
;
909 target_terminal::ours_for_output ();
911 fprintf_unfiltered (mi
->event_channel
, "breakpoint-deleted,id=\"%d\"",
914 gdb_flush (mi
->event_channel
);
918 /* Emit notification about modified breakpoint. */
921 mi_breakpoint_modified (struct breakpoint
*b
)
923 if (mi_suppress_notification
.breakpoint
)
929 SWITCH_THRU_ALL_UIS ()
931 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
936 target_terminal::scoped_restore_terminal_state term_state
;
937 target_terminal::ours_for_output ();
938 fprintf_unfiltered (mi
->event_channel
,
939 "breakpoint-modified");
940 mi_print_breakpoint_for_event (mi
, b
);
942 gdb_flush (mi
->event_channel
);
947 mi_output_running_pid (struct thread_info
*info
, void *arg
)
949 ptid_t
*ptid
= (ptid_t
*) arg
;
951 SWITCH_THRU_ALL_UIS ()
953 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
958 if (ptid_get_pid (*ptid
) == ptid_get_pid (info
->ptid
))
959 fprintf_unfiltered (mi
->raw_stdout
,
960 "*running,thread-id=\"%d\"\n",
968 mi_inferior_count (struct inferior
*inf
, void *arg
)
972 int *count_p
= (int *) arg
;
980 mi_on_resume_1 (struct mi_interp
*mi
, ptid_t ptid
)
982 /* To cater for older frontends, emit ^running, but do it only once
983 per each command. We do it here, since at this point we know
984 that the target was successfully resumed, and in non-async mode,
985 we won't return back to MI interpreter code until the target
986 is done running, so delaying the output of "^running" until then
987 will make it impossible for frontend to know what's going on.
989 In future (MI3), we'll be outputting "^done" here. */
990 if (!running_result_record_printed
&& mi_proceeded
)
992 fprintf_unfiltered (mi
->raw_stdout
, "%s^running\n",
993 current_token
? current_token
: "");
996 if (ptid_get_pid (ptid
) == -1)
997 fprintf_unfiltered (mi
->raw_stdout
, "*running,thread-id=\"all\"\n");
998 else if (ptid_is_pid (ptid
))
1002 /* Backwards compatibility. If there's only one inferior,
1003 output "all", otherwise, output each resumed thread
1005 iterate_over_inferiors (mi_inferior_count
, &count
);
1008 fprintf_unfiltered (mi
->raw_stdout
, "*running,thread-id=\"all\"\n");
1010 iterate_over_threads (mi_output_running_pid
, &ptid
);
1014 struct thread_info
*ti
= find_thread_ptid (ptid
);
1017 fprintf_unfiltered (mi
->raw_stdout
, "*running,thread-id=\"%d\"\n",
1021 if (!running_result_record_printed
&& mi_proceeded
)
1023 running_result_record_printed
= 1;
1024 /* This is what gdb used to do historically -- printing prompt
1025 even if it cannot actually accept any input. This will be
1026 surely removed for MI3, and may be removed even earlier. */
1027 if (current_ui
->prompt_state
== PROMPT_BLOCKED
)
1028 fputs_unfiltered ("(gdb) \n", mi
->raw_stdout
);
1030 gdb_flush (mi
->raw_stdout
);
1034 mi_on_resume (ptid_t ptid
)
1036 struct thread_info
*tp
= NULL
;
1038 if (ptid_equal (ptid
, minus_one_ptid
) || ptid_is_pid (ptid
))
1039 tp
= inferior_thread ();
1041 tp
= find_thread_ptid (ptid
);
1043 /* Suppress output while calling an inferior function. */
1044 if (tp
->control
.in_infcall
)
1047 SWITCH_THRU_ALL_UIS ()
1049 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1054 target_terminal::scoped_restore_terminal_state term_state
;
1055 target_terminal::ours_for_output ();
1057 mi_on_resume_1 (mi
, ptid
);
1061 /* See mi-interp.h. */
1064 mi_output_solib_attribs (ui_out
*uiout
, struct so_list
*solib
)
1066 struct gdbarch
*gdbarch
= target_gdbarch ();
1068 uiout
->field_string ("id", solib
->so_original_name
);
1069 uiout
->field_string ("target-name", solib
->so_original_name
);
1070 uiout
->field_string ("host-name", solib
->so_name
);
1071 uiout
->field_int ("symbols-loaded", solib
->symbols_loaded
);
1072 if (!gdbarch_has_global_solist (target_gdbarch ()))
1073 uiout
->field_fmt ("thread-group", "i%d", current_inferior ()->num
);
1075 ui_out_emit_list
list_emitter (uiout
, "ranges");
1076 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1077 if (solib
->addr_high
!= 0)
1079 uiout
->field_core_addr ("from", gdbarch
, solib
->addr_low
);
1080 uiout
->field_core_addr ("to", gdbarch
, solib
->addr_high
);
1085 mi_solib_loaded (struct so_list
*solib
)
1087 SWITCH_THRU_ALL_UIS ()
1089 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1090 struct ui_out
*uiout
;
1095 uiout
= interp_ui_out (top_level_interpreter ());
1097 target_terminal::scoped_restore_terminal_state term_state
;
1098 target_terminal::ours_for_output ();
1100 fprintf_unfiltered (mi
->event_channel
, "library-loaded");
1102 uiout
->redirect (mi
->event_channel
);
1104 mi_output_solib_attribs (uiout
, solib
);
1106 uiout
->redirect (NULL
);
1108 gdb_flush (mi
->event_channel
);
1113 mi_solib_unloaded (struct so_list
*solib
)
1115 SWITCH_THRU_ALL_UIS ()
1117 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1118 struct ui_out
*uiout
;
1123 uiout
= interp_ui_out (top_level_interpreter ());
1125 target_terminal::scoped_restore_terminal_state term_state
;
1126 target_terminal::ours_for_output ();
1128 fprintf_unfiltered (mi
->event_channel
, "library-unloaded");
1130 uiout
->redirect (mi
->event_channel
);
1132 uiout
->field_string ("id", solib
->so_original_name
);
1133 uiout
->field_string ("target-name", solib
->so_original_name
);
1134 uiout
->field_string ("host-name", solib
->so_name
);
1135 if (!gdbarch_has_global_solist (target_gdbarch ()))
1137 uiout
->field_fmt ("thread-group", "i%d", current_inferior ()->num
);
1140 uiout
->redirect (NULL
);
1142 gdb_flush (mi
->event_channel
);
1146 /* Emit notification about the command parameter change. */
1149 mi_command_param_changed (const char *param
, const char *value
)
1151 if (mi_suppress_notification
.cmd_param_changed
)
1154 SWITCH_THRU_ALL_UIS ()
1156 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1157 struct ui_out
*mi_uiout
;
1162 mi_uiout
= interp_ui_out (top_level_interpreter ());
1164 target_terminal::scoped_restore_terminal_state term_state
;
1165 target_terminal::ours_for_output ();
1167 fprintf_unfiltered (mi
->event_channel
, "cmd-param-changed");
1169 mi_uiout
->redirect (mi
->event_channel
);
1171 mi_uiout
->field_string ("param", param
);
1172 mi_uiout
->field_string ("value", value
);
1174 mi_uiout
->redirect (NULL
);
1176 gdb_flush (mi
->event_channel
);
1180 /* Emit notification about the target memory change. */
1183 mi_memory_changed (struct inferior
*inferior
, CORE_ADDR memaddr
,
1184 ssize_t len
, const bfd_byte
*myaddr
)
1186 if (mi_suppress_notification
.memory
)
1189 SWITCH_THRU_ALL_UIS ()
1191 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1192 struct ui_out
*mi_uiout
;
1193 struct obj_section
*sec
;
1198 mi_uiout
= interp_ui_out (top_level_interpreter ());
1200 target_terminal::scoped_restore_terminal_state term_state
;
1201 target_terminal::ours_for_output ();
1203 fprintf_unfiltered (mi
->event_channel
, "memory-changed");
1205 mi_uiout
->redirect (mi
->event_channel
);
1207 mi_uiout
->field_fmt ("thread-group", "i%d", inferior
->num
);
1208 mi_uiout
->field_core_addr ("addr", target_gdbarch (), memaddr
);
1209 mi_uiout
->field_fmt ("len", "%s", hex_string (len
));
1211 /* Append 'type=code' into notification if MEMADDR falls in the range of
1212 sections contain code. */
1213 sec
= find_pc_section (memaddr
);
1214 if (sec
!= NULL
&& sec
->objfile
!= NULL
)
1216 flagword flags
= bfd_get_section_flags (sec
->objfile
->obfd
,
1217 sec
->the_bfd_section
);
1219 if (flags
& SEC_CODE
)
1220 mi_uiout
->field_string ("type", "code");
1223 mi_uiout
->redirect (NULL
);
1225 gdb_flush (mi
->event_channel
);
1229 /* Emit an event when the selection context (inferior, thread, frame)
1233 mi_user_selected_context_changed (user_selected_what selection
)
1235 struct thread_info
*tp
;
1237 /* Don't send an event if we're responding to an MI command. */
1238 if (mi_suppress_notification
.user_selected_context
)
1241 tp
= find_thread_ptid (inferior_ptid
);
1243 SWITCH_THRU_ALL_UIS ()
1245 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1246 struct ui_out
*mi_uiout
;
1251 mi_uiout
= interp_ui_out (top_level_interpreter ());
1253 mi_uiout
->redirect (mi
->event_channel
);
1254 ui_out_redirect_pop
redirect_popper (mi_uiout
);
1256 target_terminal::scoped_restore_terminal_state term_state
;
1257 target_terminal::ours_for_output ();
1259 if (selection
& USER_SELECTED_INFERIOR
)
1260 print_selected_inferior (mi
->cli_uiout
);
1263 && (selection
& (USER_SELECTED_THREAD
| USER_SELECTED_FRAME
)))
1265 print_selected_thread_frame (mi
->cli_uiout
, selection
);
1267 fprintf_unfiltered (mi
->event_channel
,
1268 "thread-selected,id=\"%d\"",
1271 if (tp
->state
!= THREAD_RUNNING
)
1273 if (has_stack_frames ())
1274 print_stack_frame_to_uiout (mi_uiout
, get_selected_frame (NULL
),
1279 gdb_flush (mi
->event_channel
);
1284 report_initial_inferior (struct inferior
*inf
, void *closure
)
1286 /* This function is called from mi_interpreter_init, and since
1287 mi_inferior_added assumes that inferior is fully initialized
1288 and top_level_interpreter_data is set, we cannot call
1290 struct mi_interp
*mi
= (struct mi_interp
*) closure
;
1292 target_terminal::scoped_restore_terminal_state term_state
;
1293 target_terminal::ours_for_output ();
1295 fprintf_unfiltered (mi
->event_channel
,
1296 "thread-group-added,id=\"i%d\"",
1298 gdb_flush (mi
->event_channel
);
1304 mi_interp::interp_ui_out ()
1306 return this->mi_uiout
;
1309 /* Do MI-specific logging actions; save raw_stdout, and change all
1310 the consoles to use the supplied ui-file(s). */
1313 mi_interp::set_logging (ui_file_up logfile
, bool logging_redirect
)
1315 struct mi_interp
*mi
= this;
1317 if (logfile
!= NULL
)
1319 mi
->saved_raw_stdout
= mi
->raw_stdout
;
1320 mi
->raw_stdout
= make_logging_output (mi
->raw_stdout
,
1321 std::move (logfile
),
1327 delete mi
->raw_stdout
;
1328 mi
->raw_stdout
= mi
->saved_raw_stdout
;
1329 mi
->saved_raw_stdout
= NULL
;
1332 mi
->out
->set_raw (mi
->raw_stdout
);
1333 mi
->err
->set_raw (mi
->raw_stdout
);
1334 mi
->log
->set_raw (mi
->raw_stdout
);
1335 mi
->targ
->set_raw (mi
->raw_stdout
);
1336 mi
->event_channel
->set_raw (mi
->raw_stdout
);
1339 /* Factory for MI interpreters. */
1341 static struct interp
*
1342 mi_interp_factory (const char *name
)
1344 return new mi_interp (name
);
1348 _initialize_mi_interp (void)
1350 /* The various interpreter levels. */
1351 interp_factory_register (INTERP_MI1
, mi_interp_factory
);
1352 interp_factory_register (INTERP_MI2
, mi_interp_factory
);
1353 interp_factory_register (INTERP_MI3
, mi_interp_factory
);
1354 interp_factory_register (INTERP_MI
, mi_interp_factory
);
1356 gdb::observers::signal_received
.attach (mi_on_signal_received
);
1357 gdb::observers::end_stepping_range
.attach (mi_on_end_stepping_range
);
1358 gdb::observers::signal_exited
.attach (mi_on_signal_exited
);
1359 gdb::observers::exited
.attach (mi_on_exited
);
1360 gdb::observers::no_history
.attach (mi_on_no_history
);
1361 gdb::observers::new_thread
.attach (mi_new_thread
);
1362 gdb::observers::thread_exit
.attach (mi_thread_exit
);
1363 gdb::observers::inferior_added
.attach (mi_inferior_added
);
1364 gdb::observers::inferior_appeared
.attach (mi_inferior_appeared
);
1365 gdb::observers::inferior_exit
.attach (mi_inferior_exit
);
1366 gdb::observers::inferior_removed
.attach (mi_inferior_removed
);
1367 gdb::observers::record_changed
.attach (mi_record_changed
);
1368 gdb::observers::normal_stop
.attach (mi_on_normal_stop
);
1369 gdb::observers::target_resumed
.attach (mi_on_resume
);
1370 gdb::observers::solib_loaded
.attach (mi_solib_loaded
);
1371 gdb::observers::solib_unloaded
.attach (mi_solib_unloaded
);
1372 gdb::observers::about_to_proceed
.attach (mi_about_to_proceed
);
1373 gdb::observers::traceframe_changed
.attach (mi_traceframe_changed
);
1374 gdb::observers::tsv_created
.attach (mi_tsv_created
);
1375 gdb::observers::tsv_deleted
.attach (mi_tsv_deleted
);
1376 gdb::observers::tsv_modified
.attach (mi_tsv_modified
);
1377 gdb::observers::breakpoint_created
.attach (mi_breakpoint_created
);
1378 gdb::observers::breakpoint_deleted
.attach (mi_breakpoint_deleted
);
1379 gdb::observers::breakpoint_modified
.attach (mi_breakpoint_modified
);
1380 gdb::observers::command_param_changed
.attach (mi_command_param_changed
);
1381 gdb::observers::memory_changed
.attach (mi_memory_changed
);
1382 gdb::observers::sync_execution_done
.attach (mi_on_sync_execution_done
);
1383 gdb::observers::user_selected_context_changed
.attach
1384 (mi_user_selected_context_changed
);