1 /* MI Interpreter Definitions and Commands for GDB, the GNU debugger.
3 Copyright (C) 2002-2023 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 "mi-interp.h"
25 #include "event-top.h"
26 #include "gdbsupport/event-loop.h"
34 #include "mi-console.h"
35 #include "mi-common.h"
36 #include "observable.h"
37 #include "gdbthread.h"
40 #include "tracepoint.h"
42 #include "thread-fsm.h"
43 #include "cli/cli-interp.h"
44 #include "gdbsupport/scope-exit.h"
46 /* These are the interpreter setup, etc. functions for the MI
49 static void mi_execute_command_wrapper (const char *cmd
);
50 static void mi_execute_command_input_handler
51 (gdb::unique_xmalloc_ptr
<char> &&cmd
);
53 /* These are hooks that we put in place while doing interpreter_exec
54 so we can report interesting things that happened "behind the MI's
55 back" in this command. */
57 static int mi_interp_query_hook (const char *ctlstr
, va_list ap
)
58 ATTRIBUTE_PRINTF (1, 0);
60 static void mi_insert_notify_hooks (void);
61 static void mi_remove_notify_hooks (void);
63 static void mi_on_signal_received (enum gdb_signal siggnal
);
64 static void mi_on_end_stepping_range (void);
65 static void mi_on_signal_exited (enum gdb_signal siggnal
);
66 static void mi_on_exited (int exitstatus
);
67 static void mi_on_normal_stop (struct bpstat
*bs
, int print_frame
);
68 static void mi_on_no_history (void);
70 static void mi_new_thread (struct thread_info
*t
);
71 static void mi_thread_exit (struct thread_info
*t
, int silent
);
72 static void mi_record_changed (struct inferior
*, int, const char *,
74 static void mi_inferior_added (struct inferior
*inf
);
75 static void mi_inferior_appeared (struct inferior
*inf
);
76 static void mi_inferior_exit (struct inferior
*inf
);
77 static void mi_inferior_removed (struct inferior
*inf
);
78 static void mi_on_resume (ptid_t ptid
);
79 static void mi_solib_loaded (struct so_list
*solib
);
80 static void mi_solib_unloaded (struct so_list
*solib
);
81 static void mi_about_to_proceed (void);
82 static void mi_traceframe_changed (int tfnum
, int tpnum
);
83 static void mi_tsv_created (const struct trace_state_variable
*tsv
);
84 static void mi_tsv_deleted (const struct trace_state_variable
*tsv
);
85 static void mi_tsv_modified (const struct trace_state_variable
*tsv
);
86 static void mi_breakpoint_created (struct breakpoint
*b
);
87 static void mi_breakpoint_deleted (struct breakpoint
*b
);
88 static void mi_breakpoint_modified (struct breakpoint
*b
);
89 static void mi_command_param_changed (const char *param
, const char *value
);
90 static void mi_memory_changed (struct inferior
*inf
, CORE_ADDR memaddr
,
91 ssize_t len
, const bfd_byte
*myaddr
);
92 static void mi_on_sync_execution_done (void);
94 /* Display the MI prompt. */
97 display_mi_prompt (struct mi_interp
*mi
)
99 struct ui
*ui
= current_ui
;
101 gdb_puts ("(gdb) \n", mi
->raw_stdout
);
102 gdb_flush (mi
->raw_stdout
);
103 ui
->prompt_state
= PROMPTED
;
106 /* Returns the INTERP's data cast as mi_interp if INTERP is an MI, and
107 returns NULL otherwise. */
109 static struct mi_interp
*
110 as_mi_interp (struct interp
*interp
)
112 return dynamic_cast<mi_interp
*> (interp
);
115 /* Observer for the command_error notification. */
118 mi_on_command_error ()
120 mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
122 display_mi_prompt (mi
);
126 mi_interp::init (bool top_level
)
128 mi_interp
*mi
= this;
130 /* Store the current output channel, so that we can create a console
131 channel that encapsulates and prefixes all gdb_output-type bits
132 coming from the rest of the debugger. */
133 mi
->raw_stdout
= gdb_stdout
;
135 /* Create MI console channels, each with a different prefix so they
136 can be distinguished. */
137 mi
->out
= new mi_console_file (mi
->raw_stdout
, "~", '"');
138 mi
->err
= new mi_console_file (mi
->raw_stdout
, "&", '"');
140 mi
->targ
= new mi_console_file (mi
->raw_stdout
, "@", '"');
141 mi
->event_channel
= new mi_console_file (mi
->raw_stdout
, "=", 0);
142 mi
->mi_uiout
= mi_out_new (name ());
143 gdb_assert (mi
->mi_uiout
!= nullptr);
144 mi
->cli_uiout
= new cli_ui_out (mi
->out
);
148 /* The initial inferior is created before this function is called, so we
149 need to report it explicitly when initializing the top-level MI
152 This is also called when additional MI interpreters are added (using
153 the new-ui command), when multiple inferiors possibly exist, so we need
154 to use iteration to report all the inferiors. mi_inferior_added can't
155 be used, because it would print the event on all the other MI UIs. */
157 for (inferior
*inf
: all_inferiors ())
159 target_terminal::scoped_restore_terminal_state term_state
;
160 target_terminal::ours_for_output ();
162 gdb_printf (mi
->event_channel
,
163 "thread-group-added,id=\"i%d\"",
166 gdb_flush (mi
->event_channel
);
174 struct mi_interp
*mi
= this;
175 struct ui
*ui
= current_ui
;
177 /* As per hack note in mi_interpreter_init, swap in the output
179 gdb_setup_readline (0);
181 ui
->call_readline
= gdb_readline_no_editing_callback
;
182 ui
->input_handler
= mi_execute_command_input_handler
;
184 gdb_stdout
= mi
->out
;
185 /* Route error and log output through the MI. */
186 gdb_stderr
= mi
->err
;
187 gdb_stdlog
= mi
->log
;
188 /* Route target output through the MI. */
189 gdb_stdtarg
= mi
->targ
;
190 /* Route target error through the MI as well. */
191 gdb_stdtargerr
= mi
->targ
;
193 deprecated_show_load_progress
= mi_load_progress
;
197 mi_interp::suspend ()
199 gdb_disable_readline ();
203 mi_interp::exec (const char *command
)
205 mi_execute_command_wrapper (command
);
206 return gdb_exception ();
210 mi_cmd_interpreter_exec (const char *command
, char **argv
, int argc
)
212 struct interp
*interp_to_use
;
216 error (_("-interpreter-exec: "
217 "Usage: -interpreter-exec interp command"));
219 interp_to_use
= interp_lookup (current_ui
, argv
[0]);
220 if (interp_to_use
== NULL
)
221 error (_("-interpreter-exec: could not find interpreter \"%s\""),
224 /* Note that unlike the CLI version of this command, we don't
225 actually set INTERP_TO_USE as the current interpreter, as we
226 still want gdb_stdout, etc. to point at MI streams. */
228 /* Insert the MI out hooks, making sure to also call the
229 interpreter's hooks if it has any. */
230 /* KRS: We shouldn't need this... Events should be installed and
231 they should just ALWAYS fire something out down the MI
233 mi_insert_notify_hooks ();
235 /* Now run the code. */
239 mi_remove_notify_hooks ();
242 for (i
= 1; i
< argc
; i
++)
244 struct gdb_exception e
= interp_exec (interp_to_use
, argv
[i
]);
247 error ("%s", e
.what ());
251 /* This inserts a number of hooks that are meant to produce
252 async-notify ("=") MI messages while running commands in another
253 interpreter using mi_interpreter_exec. The canonical use for this
254 is to allow access to the gdb CLI interpreter from within the MI,
255 while still producing MI style output when actions in the CLI
256 command change GDB's state. */
259 mi_insert_notify_hooks (void)
261 deprecated_query_hook
= mi_interp_query_hook
;
265 mi_remove_notify_hooks (void)
267 deprecated_query_hook
= NULL
;
271 mi_interp_query_hook (const char *ctlstr
, va_list ap
)
277 mi_execute_command_wrapper (const char *cmd
)
279 struct ui
*ui
= current_ui
;
281 mi_execute_command (cmd
, ui
->instream
== ui
->stdin_stream
);
284 /* Observer for the synchronous_command_done notification. */
287 mi_on_sync_execution_done (void)
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 (gdb::unique_xmalloc_ptr
<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
.get ());
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 SWITCH_THRU_ALL_UIS ()
339 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
344 target_terminal::scoped_restore_terminal_state term_state
;
345 target_terminal::ours_for_output ();
347 gdb_printf (mi
->event_channel
,
348 "thread-created,id=\"%d\",group-id=\"i%d\"",
349 t
->global_num
, t
->inf
->num
);
350 gdb_flush (mi
->event_channel
);
355 mi_thread_exit (struct thread_info
*t
, int silent
)
357 SWITCH_THRU_ALL_UIS ()
359 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
364 target_terminal::scoped_restore_terminal_state term_state
;
365 target_terminal::ours_for_output ();
366 gdb_printf (mi
->event_channel
,
367 "thread-exited,id=\"%d\",group-id=\"i%d\"",
368 t
->global_num
, t
->inf
->num
);
369 gdb_flush (mi
->event_channel
);
373 /* Emit notification on changing the state of record. */
376 mi_record_changed (struct inferior
*inferior
, int started
, const char *method
,
379 SWITCH_THRU_ALL_UIS ()
381 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
386 target_terminal::scoped_restore_terminal_state term_state
;
387 target_terminal::ours_for_output ();
393 gdb_printf (mi
->event_channel
,
394 "record-started,thread-group=\"i%d\","
395 "method=\"%s\",format=\"%s\"",
396 inferior
->num
, method
, format
);
400 gdb_printf (mi
->event_channel
,
401 "record-started,thread-group=\"i%d\","
403 inferior
->num
, method
);
408 gdb_printf (mi
->event_channel
,
409 "record-stopped,thread-group=\"i%d\"",
413 gdb_flush (mi
->event_channel
);
418 mi_inferior_added (struct inferior
*inf
)
420 SWITCH_THRU_ALL_UIS ()
422 struct interp
*interp
;
423 struct mi_interp
*mi
;
425 /* We'll be called once for the initial inferior, before the top
426 level interpreter is set. */
427 interp
= top_level_interpreter ();
431 mi
= as_mi_interp (interp
);
435 target_terminal::scoped_restore_terminal_state term_state
;
436 target_terminal::ours_for_output ();
438 gdb_printf (mi
->event_channel
,
439 "thread-group-added,id=\"i%d\"",
441 gdb_flush (mi
->event_channel
);
446 mi_inferior_appeared (struct inferior
*inf
)
448 SWITCH_THRU_ALL_UIS ()
450 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
455 target_terminal::scoped_restore_terminal_state term_state
;
456 target_terminal::ours_for_output ();
458 gdb_printf (mi
->event_channel
,
459 "thread-group-started,id=\"i%d\",pid=\"%d\"",
461 gdb_flush (mi
->event_channel
);
466 mi_inferior_exit (struct inferior
*inf
)
468 SWITCH_THRU_ALL_UIS ()
470 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
475 target_terminal::scoped_restore_terminal_state term_state
;
476 target_terminal::ours_for_output ();
478 if (inf
->has_exit_code
)
479 gdb_printf (mi
->event_channel
,
480 "thread-group-exited,id=\"i%d\",exit-code=\"%s\"",
481 inf
->num
, int_string (inf
->exit_code
, 8, 0, 0, 1));
483 gdb_printf (mi
->event_channel
,
484 "thread-group-exited,id=\"i%d\"", inf
->num
);
486 gdb_flush (mi
->event_channel
);
491 mi_inferior_removed (struct inferior
*inf
)
493 SWITCH_THRU_ALL_UIS ()
495 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
500 target_terminal::scoped_restore_terminal_state term_state
;
501 target_terminal::ours_for_output ();
503 gdb_printf (mi
->event_channel
,
504 "thread-group-removed,id=\"i%d\"",
506 gdb_flush (mi
->event_channel
);
510 /* Return the MI interpreter, if it is active -- either because it's
511 the top-level interpreter or the interpreter executing the current
512 command. Returns NULL if the MI interpreter is not being used. */
514 static struct mi_interp
*
515 find_mi_interp (void)
517 struct mi_interp
*mi
;
519 mi
= as_mi_interp (top_level_interpreter ());
523 mi
= as_mi_interp (command_interp ());
530 /* Observers for several run control events that print why the
531 inferior has stopped to both the MI event channel and to the MI
532 console. If the MI interpreter is not active, print nothing. */
534 /* Observer for the signal_received notification. */
537 mi_on_signal_received (enum gdb_signal siggnal
)
539 SWITCH_THRU_ALL_UIS ()
541 struct mi_interp
*mi
= find_mi_interp ();
546 print_signal_received_reason (mi
->mi_uiout
, siggnal
);
547 print_signal_received_reason (mi
->cli_uiout
, siggnal
);
551 /* Observer for the end_stepping_range notification. */
554 mi_on_end_stepping_range (void)
556 SWITCH_THRU_ALL_UIS ()
558 struct mi_interp
*mi
= find_mi_interp ();
563 print_end_stepping_range_reason (mi
->mi_uiout
);
564 print_end_stepping_range_reason (mi
->cli_uiout
);
568 /* Observer for the signal_exited notification. */
571 mi_on_signal_exited (enum gdb_signal siggnal
)
573 SWITCH_THRU_ALL_UIS ()
575 struct mi_interp
*mi
= find_mi_interp ();
580 print_signal_exited_reason (mi
->mi_uiout
, siggnal
);
581 print_signal_exited_reason (mi
->cli_uiout
, siggnal
);
585 /* Observer for the exited notification. */
588 mi_on_exited (int exitstatus
)
590 SWITCH_THRU_ALL_UIS ()
592 struct mi_interp
*mi
= find_mi_interp ();
597 print_exited_reason (mi
->mi_uiout
, exitstatus
);
598 print_exited_reason (mi
->cli_uiout
, exitstatus
);
602 /* Observer for the no_history notification. */
605 mi_on_no_history (void)
607 SWITCH_THRU_ALL_UIS ()
609 struct mi_interp
*mi
= find_mi_interp ();
614 print_no_history_reason (mi
->mi_uiout
);
615 print_no_history_reason (mi
->cli_uiout
);
620 mi_on_normal_stop_1 (struct bpstat
*bs
, int print_frame
)
622 /* Since this can be called when CLI command is executing,
623 using cli interpreter, be sure to use MI uiout for output,
624 not the current one. */
625 struct ui_out
*mi_uiout
= top_level_interpreter ()->interp_ui_out ();
626 struct mi_interp
*mi
= (struct mi_interp
*) top_level_interpreter ();
630 struct thread_info
*tp
;
632 struct interp
*console_interp
;
634 tp
= inferior_thread ();
636 if (tp
->thread_fsm () != nullptr
637 && tp
->thread_fsm ()->finished_p ())
639 enum async_reply_reason reason
;
641 reason
= tp
->thread_fsm ()->async_reply_reason ();
642 mi_uiout
->field_string ("reason", async_reason_lookup (reason
));
645 console_interp
= interp_lookup (current_ui
, INTERP_CONSOLE
);
646 /* We only want to print the displays once, and we want it to
647 look just how it would on the console, so we use this to
648 decide whether the MI stop should include them. */
649 bool console_print
= should_print_stop_to_console (console_interp
, tp
);
650 print_stop_event (mi_uiout
, !console_print
);
653 print_stop_event (mi
->cli_uiout
);
655 mi_uiout
->field_signed ("thread-id", tp
->global_num
);
658 ui_out_emit_list
list_emitter (mi_uiout
, "stopped-threads");
660 mi_uiout
->field_signed (NULL
, tp
->global_num
);
663 mi_uiout
->field_string ("stopped-threads", "all");
665 core
= target_core_of_thread (tp
->ptid
);
667 mi_uiout
->field_signed ("core", core
);
670 gdb_puts ("*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 gdb_puts ("\n", mi
->raw_stdout
);
675 gdb_flush (mi
->raw_stdout
);
679 mi_on_normal_stop (struct bpstat
*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 (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 gdb_printf (mi
->event_channel
, "traceframe-changed,"
737 "num=\"%d\",tracepoint=\"%d\"",
740 gdb_printf (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 gdb_printf (mi
->event_channel
, "tsv-created,"
762 "name=\"%s\",initial=\"%s\"",
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 gdb_printf (mi
->event_channel
, "tsv-deleted,"
786 "name=\"%s\"", tsv
->name
.c_str ());
788 gdb_printf (mi
->event_channel
, "tsv-deleted");
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
= top_level_interpreter ()->interp_ui_out ();
809 target_terminal::scoped_restore_terminal_state term_state
;
810 target_terminal::ours_for_output ();
812 gdb_printf (mi
->event_channel
,
815 ui_out_redirect_pop
redir (mi_uiout
, 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 gdb_flush (mi
->event_channel
);
827 /* Print breakpoint BP on MI's event channel. */
830 mi_print_breakpoint_for_event (struct mi_interp
*mi
, breakpoint
*bp
)
832 ui_out
*mi_uiout
= mi
->interp_ui_out ();
834 /* We want the output from print_breakpoint to go to
835 mi->event_channel. One approach would be to just call
836 print_breakpoint, and then use mi_out_put to send the current
837 content of mi_uiout into mi->event_channel. However, that will
838 break if anything is output to mi_uiout prior to calling the
839 breakpoint_created notifications. So, we use
841 ui_out_redirect_pop
redir (mi_uiout
, mi
->event_channel
);
845 scoped_restore restore_uiout
846 = make_scoped_restore (¤t_uiout
, mi_uiout
);
848 print_breakpoint (bp
);
850 catch (const gdb_exception
&ex
)
852 exception_print (gdb_stderr
, ex
);
856 /* Emit notification about a created breakpoint. */
859 mi_breakpoint_created (struct breakpoint
*b
)
861 if (mi_suppress_notification
.breakpoint
)
867 SWITCH_THRU_ALL_UIS ()
869 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
874 target_terminal::scoped_restore_terminal_state term_state
;
875 target_terminal::ours_for_output ();
877 gdb_printf (mi
->event_channel
,
878 "breakpoint-created");
879 mi_print_breakpoint_for_event (mi
, b
);
881 gdb_flush (mi
->event_channel
);
885 /* Emit notification about deleted breakpoint. */
888 mi_breakpoint_deleted (struct breakpoint
*b
)
890 if (mi_suppress_notification
.breakpoint
)
896 SWITCH_THRU_ALL_UIS ()
898 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
903 target_terminal::scoped_restore_terminal_state term_state
;
904 target_terminal::ours_for_output ();
906 gdb_printf (mi
->event_channel
, "breakpoint-deleted,id=\"%d\"",
909 gdb_flush (mi
->event_channel
);
913 /* Emit notification about modified breakpoint. */
916 mi_breakpoint_modified (struct breakpoint
*b
)
918 if (mi_suppress_notification
.breakpoint
)
924 SWITCH_THRU_ALL_UIS ()
926 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
931 target_terminal::scoped_restore_terminal_state term_state
;
932 target_terminal::ours_for_output ();
933 gdb_printf (mi
->event_channel
,
934 "breakpoint-modified");
935 mi_print_breakpoint_for_event (mi
, b
);
937 gdb_flush (mi
->event_channel
);
942 mi_output_running (struct thread_info
*thread
)
944 SWITCH_THRU_ALL_UIS ()
946 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
951 gdb_printf (mi
->raw_stdout
,
952 "*running,thread-id=\"%d\"\n",
957 /* Return true if there are multiple inferiors loaded. This is used
958 for backwards compatibility -- if there's only one inferior, output
959 "all", otherwise, output each resumed thread individually. */
962 multiple_inferiors_p ()
965 for (inferior
*inf ATTRIBUTE_UNUSED
: all_non_exited_inferiors ())
976 mi_on_resume_1 (struct mi_interp
*mi
,
977 process_stratum_target
*targ
, ptid_t ptid
)
979 /* To cater for older frontends, emit ^running, but do it only once
980 per each command. We do it here, since at this point we know
981 that the target was successfully resumed, and in non-async mode,
982 we won't return back to MI interpreter code until the target
983 is done running, so delaying the output of "^running" until then
984 will make it impossible for frontend to know what's going on.
986 In future (MI3), we'll be outputting "^done" here. */
987 if (!running_result_record_printed
&& mi_proceeded
)
989 gdb_printf (mi
->raw_stdout
, "%s^running\n",
990 current_token
? current_token
: "");
993 /* Backwards compatibility. If doing a wildcard resume and there's
994 only one inferior, output "all", otherwise, output each resumed
995 thread individually. */
996 if ((ptid
== minus_one_ptid
|| ptid
.is_pid ())
997 && !multiple_inferiors_p ())
998 gdb_printf (mi
->raw_stdout
, "*running,thread-id=\"all\"\n");
1000 for (thread_info
*tp
: all_non_exited_threads (targ
, ptid
))
1001 mi_output_running (tp
);
1003 if (!running_result_record_printed
&& mi_proceeded
)
1005 running_result_record_printed
= 1;
1006 /* This is what gdb used to do historically -- printing prompt
1007 even if it cannot actually accept any input. This will be
1008 surely removed for MI3, and may be removed even earlier. */
1009 if (current_ui
->prompt_state
== PROMPT_BLOCKED
)
1010 gdb_puts ("(gdb) \n", mi
->raw_stdout
);
1012 gdb_flush (mi
->raw_stdout
);
1016 mi_on_resume (ptid_t ptid
)
1018 struct thread_info
*tp
= NULL
;
1020 process_stratum_target
*target
= current_inferior ()->process_target ();
1021 if (ptid
== minus_one_ptid
|| ptid
.is_pid ())
1022 tp
= inferior_thread ();
1024 tp
= find_thread_ptid (target
, ptid
);
1026 /* Suppress output while calling an inferior function. */
1027 if (tp
->control
.in_infcall
)
1030 SWITCH_THRU_ALL_UIS ()
1032 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1037 target_terminal::scoped_restore_terminal_state term_state
;
1038 target_terminal::ours_for_output ();
1040 mi_on_resume_1 (mi
, target
, ptid
);
1044 /* See mi-interp.h. */
1047 mi_output_solib_attribs (ui_out
*uiout
, struct so_list
*solib
)
1049 struct gdbarch
*gdbarch
= target_gdbarch ();
1051 uiout
->field_string ("id", solib
->so_original_name
);
1052 uiout
->field_string ("target-name", solib
->so_original_name
);
1053 uiout
->field_string ("host-name", solib
->so_name
);
1054 uiout
->field_signed ("symbols-loaded", solib
->symbols_loaded
);
1055 if (!gdbarch_has_global_solist (target_gdbarch ()))
1056 uiout
->field_fmt ("thread-group", "i%d", current_inferior ()->num
);
1058 ui_out_emit_list
list_emitter (uiout
, "ranges");
1059 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1060 if (solib
->addr_high
!= 0)
1062 uiout
->field_core_addr ("from", gdbarch
, solib
->addr_low
);
1063 uiout
->field_core_addr ("to", gdbarch
, solib
->addr_high
);
1068 mi_solib_loaded (struct so_list
*solib
)
1070 SWITCH_THRU_ALL_UIS ()
1072 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1073 struct ui_out
*uiout
;
1078 uiout
= top_level_interpreter ()->interp_ui_out ();
1080 target_terminal::scoped_restore_terminal_state term_state
;
1081 target_terminal::ours_for_output ();
1083 gdb_printf (mi
->event_channel
, "library-loaded");
1085 ui_out_redirect_pop
redir (uiout
, mi
->event_channel
);
1087 mi_output_solib_attribs (uiout
, solib
);
1089 gdb_flush (mi
->event_channel
);
1094 mi_solib_unloaded (struct so_list
*solib
)
1096 SWITCH_THRU_ALL_UIS ()
1098 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1099 struct ui_out
*uiout
;
1104 uiout
= top_level_interpreter ()->interp_ui_out ();
1106 target_terminal::scoped_restore_terminal_state term_state
;
1107 target_terminal::ours_for_output ();
1109 gdb_printf (mi
->event_channel
, "library-unloaded");
1111 ui_out_redirect_pop
redir (uiout
, mi
->event_channel
);
1113 uiout
->field_string ("id", solib
->so_original_name
);
1114 uiout
->field_string ("target-name", solib
->so_original_name
);
1115 uiout
->field_string ("host-name", solib
->so_name
);
1116 if (!gdbarch_has_global_solist (target_gdbarch ()))
1118 uiout
->field_fmt ("thread-group", "i%d", current_inferior ()->num
);
1121 gdb_flush (mi
->event_channel
);
1125 /* Emit notification about the command parameter change. */
1128 mi_command_param_changed (const char *param
, const char *value
)
1130 if (mi_suppress_notification
.cmd_param_changed
)
1133 SWITCH_THRU_ALL_UIS ()
1135 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1136 struct ui_out
*mi_uiout
;
1141 mi_uiout
= top_level_interpreter ()->interp_ui_out ();
1143 target_terminal::scoped_restore_terminal_state term_state
;
1144 target_terminal::ours_for_output ();
1146 gdb_printf (mi
->event_channel
, "cmd-param-changed");
1148 ui_out_redirect_pop
redir (mi_uiout
, mi
->event_channel
);
1150 mi_uiout
->field_string ("param", param
);
1151 mi_uiout
->field_string ("value", value
);
1153 gdb_flush (mi
->event_channel
);
1157 /* Emit notification about the target memory change. */
1160 mi_memory_changed (struct inferior
*inferior
, CORE_ADDR memaddr
,
1161 ssize_t len
, const bfd_byte
*myaddr
)
1163 if (mi_suppress_notification
.memory
)
1166 SWITCH_THRU_ALL_UIS ()
1168 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1169 struct ui_out
*mi_uiout
;
1170 struct obj_section
*sec
;
1175 mi_uiout
= top_level_interpreter ()->interp_ui_out ();
1177 target_terminal::scoped_restore_terminal_state term_state
;
1178 target_terminal::ours_for_output ();
1180 gdb_printf (mi
->event_channel
, "memory-changed");
1182 ui_out_redirect_pop
redir (mi_uiout
, mi
->event_channel
);
1184 mi_uiout
->field_fmt ("thread-group", "i%d", inferior
->num
);
1185 mi_uiout
->field_core_addr ("addr", target_gdbarch (), memaddr
);
1186 mi_uiout
->field_string ("len", hex_string (len
));
1188 /* Append 'type=code' into notification if MEMADDR falls in the range of
1189 sections contain code. */
1190 sec
= find_pc_section (memaddr
);
1191 if (sec
!= NULL
&& sec
->objfile
!= NULL
)
1193 flagword flags
= bfd_section_flags (sec
->the_bfd_section
);
1195 if (flags
& SEC_CODE
)
1196 mi_uiout
->field_string ("type", "code");
1199 gdb_flush (mi
->event_channel
);
1203 /* Emit an event when the selection context (inferior, thread, frame)
1207 mi_user_selected_context_changed (user_selected_what selection
)
1209 struct thread_info
*tp
;
1211 /* Don't send an event if we're responding to an MI command. */
1212 if (mi_suppress_notification
.user_selected_context
)
1215 if (inferior_ptid
!= null_ptid
)
1216 tp
= inferior_thread ();
1220 SWITCH_THRU_ALL_UIS ()
1222 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1223 struct ui_out
*mi_uiout
;
1228 mi_uiout
= top_level_interpreter ()->interp_ui_out ();
1230 ui_out_redirect_pop
redirect_popper (mi_uiout
, mi
->event_channel
);
1232 target_terminal::scoped_restore_terminal_state term_state
;
1233 target_terminal::ours_for_output ();
1235 if (selection
& USER_SELECTED_INFERIOR
)
1236 print_selected_inferior (mi
->cli_uiout
);
1239 && (selection
& (USER_SELECTED_THREAD
| USER_SELECTED_FRAME
)))
1241 print_selected_thread_frame (mi
->cli_uiout
, selection
);
1243 gdb_printf (mi
->event_channel
,
1244 "thread-selected,id=\"%d\"",
1247 if (tp
->state
!= THREAD_RUNNING
)
1249 if (has_stack_frames ())
1250 print_stack_frame_to_uiout (mi_uiout
, get_selected_frame (NULL
),
1255 gdb_flush (mi
->event_channel
);
1260 mi_interp::interp_ui_out ()
1262 return this->mi_uiout
;
1265 /* Do MI-specific logging actions; save raw_stdout, and change all
1266 the consoles to use the supplied ui-file(s). */
1269 mi_interp::set_logging (ui_file_up logfile
, bool logging_redirect
,
1270 bool debug_redirect
)
1272 struct mi_interp
*mi
= this;
1274 if (logfile
!= NULL
)
1276 mi
->saved_raw_stdout
= mi
->raw_stdout
;
1278 ui_file
*logfile_p
= logfile
.get ();
1279 mi
->logfile_holder
= std::move (logfile
);
1281 /* If something is not being redirected, then a tee containing both the
1282 logfile and stdout. */
1283 ui_file
*tee
= nullptr;
1284 if (!logging_redirect
|| !debug_redirect
)
1286 tee
= new tee_file (mi
->raw_stdout
, logfile_p
);
1287 mi
->stdout_holder
.reset (tee
);
1290 mi
->raw_stdout
= logging_redirect
? logfile_p
: tee
;
1294 mi
->logfile_holder
.reset ();
1295 mi
->stdout_holder
.reset ();
1296 mi
->raw_stdout
= mi
->saved_raw_stdout
;
1297 mi
->saved_raw_stdout
= nullptr;
1300 mi
->out
->set_raw (mi
->raw_stdout
);
1301 mi
->err
->set_raw (mi
->raw_stdout
);
1302 mi
->log
->set_raw (mi
->raw_stdout
);
1303 mi
->targ
->set_raw (mi
->raw_stdout
);
1304 mi
->event_channel
->set_raw (mi
->raw_stdout
);
1307 /* Factory for MI interpreters. */
1309 static struct interp
*
1310 mi_interp_factory (const char *name
)
1312 return new mi_interp (name
);
1315 void _initialize_mi_interp ();
1317 _initialize_mi_interp ()
1319 /* The various interpreter levels. */
1320 interp_factory_register (INTERP_MI2
, mi_interp_factory
);
1321 interp_factory_register (INTERP_MI3
, mi_interp_factory
);
1322 interp_factory_register (INTERP_MI4
, mi_interp_factory
);
1323 interp_factory_register (INTERP_MI
, mi_interp_factory
);
1325 gdb::observers::signal_received
.attach (mi_on_signal_received
, "mi-interp");
1326 gdb::observers::end_stepping_range
.attach (mi_on_end_stepping_range
,
1328 gdb::observers::signal_exited
.attach (mi_on_signal_exited
, "mi-interp");
1329 gdb::observers::exited
.attach (mi_on_exited
, "mi-interp");
1330 gdb::observers::no_history
.attach (mi_on_no_history
, "mi-interp");
1331 gdb::observers::new_thread
.attach (mi_new_thread
, "mi-interp");
1332 gdb::observers::thread_exit
.attach (mi_thread_exit
, "mi-interp");
1333 gdb::observers::inferior_added
.attach (mi_inferior_added
, "mi-interp");
1334 gdb::observers::inferior_appeared
.attach (mi_inferior_appeared
, "mi-interp");
1335 gdb::observers::inferior_exit
.attach (mi_inferior_exit
, "mi-interp");
1336 gdb::observers::inferior_removed
.attach (mi_inferior_removed
, "mi-interp");
1337 gdb::observers::record_changed
.attach (mi_record_changed
, "mi-interp");
1338 gdb::observers::normal_stop
.attach (mi_on_normal_stop
, "mi-interp");
1339 gdb::observers::target_resumed
.attach (mi_on_resume
, "mi-interp");
1340 gdb::observers::solib_loaded
.attach (mi_solib_loaded
, "mi-interp");
1341 gdb::observers::solib_unloaded
.attach (mi_solib_unloaded
, "mi-interp");
1342 gdb::observers::about_to_proceed
.attach (mi_about_to_proceed
, "mi-interp");
1343 gdb::observers::traceframe_changed
.attach (mi_traceframe_changed
,
1345 gdb::observers::tsv_created
.attach (mi_tsv_created
, "mi-interp");
1346 gdb::observers::tsv_deleted
.attach (mi_tsv_deleted
, "mi-interp");
1347 gdb::observers::tsv_modified
.attach (mi_tsv_modified
, "mi-interp");
1348 gdb::observers::breakpoint_created
.attach (mi_breakpoint_created
,
1350 gdb::observers::breakpoint_deleted
.attach (mi_breakpoint_deleted
,
1352 gdb::observers::breakpoint_modified
.attach (mi_breakpoint_modified
,
1354 gdb::observers::command_param_changed
.attach (mi_command_param_changed
,
1356 gdb::observers::command_error
.attach (mi_on_command_error
, "mi-interp");
1357 gdb::observers::memory_changed
.attach (mi_memory_changed
, "mi-interp");
1358 gdb::observers::sync_execution_done
.attach (mi_on_sync_execution_done
,
1360 gdb::observers::user_selected_context_changed
.attach
1361 (mi_user_selected_context_changed
, "mi-interp");