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 (char *command
, char **argv
, int argc
)
207 struct interp
*interp_to_use
;
209 char *mi_error_message
= NULL
;
210 struct cleanup
*old_chain
;
213 error (_("-interpreter-exec: "
214 "Usage: -interpreter-exec interp command"));
216 interp_to_use
= interp_lookup (current_ui
, argv
[0]);
217 if (interp_to_use
== NULL
)
218 error (_("-interpreter-exec: could not find interpreter \"%s\""),
221 /* Note that unlike the CLI version of this command, we don't
222 actually set INTERP_TO_USE as the current interpreter, as we
223 still want gdb_stdout, etc. to point at MI streams. */
225 /* Insert the MI out hooks, making sure to also call the
226 interpreter's hooks if it has any. */
227 /* KRS: We shouldn't need this... Events should be installed and
228 they should just ALWAYS fire something out down the MI
230 mi_insert_notify_hooks ();
232 /* Now run the code. */
234 old_chain
= make_cleanup (null_cleanup
, 0);
235 for (i
= 1; i
< argc
; i
++)
237 struct gdb_exception e
= interp_exec (interp_to_use
, argv
[i
]);
241 mi_error_message
= xstrdup (e
.message
);
242 make_cleanup (xfree
, mi_error_message
);
247 mi_remove_notify_hooks ();
249 if (mi_error_message
!= NULL
)
250 error ("%s", mi_error_message
);
251 do_cleanups (old_chain
);
254 /* This inserts a number of hooks that are meant to produce
255 async-notify ("=") MI messages while running commands in another
256 interpreter using mi_interpreter_exec. The canonical use for this
257 is to allow access to the gdb CLI interpreter from within the MI,
258 while still producing MI style output when actions in the CLI
259 command change GDB's state. */
262 mi_insert_notify_hooks (void)
264 deprecated_query_hook
= mi_interp_query_hook
;
268 mi_remove_notify_hooks (void)
270 deprecated_query_hook
= NULL
;
274 mi_interp_query_hook (const char *ctlstr
, va_list ap
)
280 mi_execute_command_wrapper (const char *cmd
)
282 struct ui
*ui
= current_ui
;
284 mi_execute_command (cmd
, ui
->instream
== ui
->stdin_stream
);
287 /* Observer for the synchronous_command_done notification. */
290 mi_on_sync_execution_done (void)
292 struct ui
*ui
= current_ui
;
293 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
298 /* If MI is sync, then output the MI prompt now, indicating we're
299 ready for further input. */
301 display_mi_prompt (mi
);
304 /* mi_execute_command_wrapper wrapper suitable for INPUT_HANDLER. */
307 mi_execute_command_input_handler (char *cmd
)
309 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
310 struct ui
*ui
= current_ui
;
312 ui
->prompt_state
= PROMPT_NEEDED
;
314 mi_execute_command_wrapper (cmd
);
316 /* Print a prompt, indicating we're ready for further input, unless
317 we just started a synchronous command. In that case, we're about
318 to go back to the event loop and will output the prompt in the
319 'synchronous_command_done' observer when the target next
321 if (ui
->prompt_state
== PROMPT_NEEDED
)
322 display_mi_prompt (mi
);
326 mi_interp::pre_command_loop ()
328 struct mi_interp
*mi
= this;
330 /* Turn off 8 bit strings in quoted output. Any character with the
331 high bit set is printed using C's octal format. */
332 sevenbit_strings
= 1;
334 /* Tell the world that we're alive. */
335 display_mi_prompt (mi
);
339 mi_new_thread (struct thread_info
*t
)
341 struct inferior
*inf
= find_inferior_ptid (t
->ptid
);
345 SWITCH_THRU_ALL_UIS ()
347 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
348 struct cleanup
*old_chain
;
353 old_chain
= make_cleanup_restore_target_terminal ();
354 target_terminal_ours_for_output ();
356 fprintf_unfiltered (mi
->event_channel
,
357 "thread-created,id=\"%d\",group-id=\"i%d\"",
358 t
->global_num
, inf
->num
);
359 gdb_flush (mi
->event_channel
);
361 do_cleanups (old_chain
);
366 mi_thread_exit (struct thread_info
*t
, int silent
)
371 SWITCH_THRU_ALL_UIS ()
373 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
374 struct cleanup
*old_chain
;
379 old_chain
= make_cleanup_restore_target_terminal ();
380 target_terminal_ours_for_output ();
381 fprintf_unfiltered (mi
->event_channel
,
382 "thread-exited,id=\"%d\",group-id=\"i%d\"",
383 t
->global_num
, t
->inf
->num
);
384 gdb_flush (mi
->event_channel
);
386 do_cleanups (old_chain
);
390 /* Emit notification on changing the state of record. */
393 mi_record_changed (struct inferior
*inferior
, int started
, const char *method
,
396 SWITCH_THRU_ALL_UIS ()
398 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
399 struct cleanup
*old_chain
;
404 old_chain
= make_cleanup_restore_target_terminal ();
405 target_terminal_ours_for_output ();
411 fprintf_unfiltered (mi
->event_channel
,
412 "record-started,thread-group=\"i%d\","
413 "method=\"%s\",format=\"%s\"",
414 inferior
->num
, method
, format
);
418 fprintf_unfiltered (mi
->event_channel
,
419 "record-started,thread-group=\"i%d\","
421 inferior
->num
, method
);
426 fprintf_unfiltered (mi
->event_channel
,
427 "record-stopped,thread-group=\"i%d\"",
431 gdb_flush (mi
->event_channel
);
433 do_cleanups (old_chain
);
438 mi_inferior_added (struct inferior
*inf
)
440 SWITCH_THRU_ALL_UIS ()
442 struct interp
*interp
;
443 struct mi_interp
*mi
;
444 struct cleanup
*old_chain
;
446 /* We'll be called once for the initial inferior, before the top
447 level interpreter is set. */
448 interp
= top_level_interpreter ();
452 mi
= as_mi_interp (interp
);
456 old_chain
= make_cleanup_restore_target_terminal ();
457 target_terminal_ours_for_output ();
459 fprintf_unfiltered (mi
->event_channel
,
460 "thread-group-added,id=\"i%d\"",
462 gdb_flush (mi
->event_channel
);
464 do_cleanups (old_chain
);
469 mi_inferior_appeared (struct inferior
*inf
)
471 SWITCH_THRU_ALL_UIS ()
473 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
474 struct cleanup
*old_chain
;
479 old_chain
= make_cleanup_restore_target_terminal ();
480 target_terminal_ours_for_output ();
482 fprintf_unfiltered (mi
->event_channel
,
483 "thread-group-started,id=\"i%d\",pid=\"%d\"",
485 gdb_flush (mi
->event_channel
);
486 do_cleanups (old_chain
);
491 mi_inferior_exit (struct inferior
*inf
)
493 SWITCH_THRU_ALL_UIS ()
495 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
496 struct cleanup
*old_chain
;
501 old_chain
= make_cleanup_restore_target_terminal ();
502 target_terminal_ours_for_output ();
504 if (inf
->has_exit_code
)
505 fprintf_unfiltered (mi
->event_channel
,
506 "thread-group-exited,id=\"i%d\",exit-code=\"%s\"",
507 inf
->num
, int_string (inf
->exit_code
, 8, 0, 0, 1));
509 fprintf_unfiltered (mi
->event_channel
,
510 "thread-group-exited,id=\"i%d\"", inf
->num
);
512 gdb_flush (mi
->event_channel
);
513 do_cleanups (old_chain
);
518 mi_inferior_removed (struct inferior
*inf
)
520 SWITCH_THRU_ALL_UIS ()
522 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
523 struct cleanup
*old_chain
;
528 old_chain
= make_cleanup_restore_target_terminal ();
529 target_terminal_ours_for_output ();
531 fprintf_unfiltered (mi
->event_channel
,
532 "thread-group-removed,id=\"i%d\"",
534 gdb_flush (mi
->event_channel
);
536 do_cleanups (old_chain
);
540 /* Return the MI interpreter, if it is active -- either because it's
541 the top-level interpreter or the interpreter executing the current
542 command. Returns NULL if the MI interpreter is not being used. */
544 static struct mi_interp
*
545 find_mi_interp (void)
547 struct mi_interp
*mi
;
549 mi
= as_mi_interp (top_level_interpreter ());
553 mi
= as_mi_interp (command_interp ());
560 /* Observers for several run control events that print why the
561 inferior has stopped to both the the MI event channel and to the MI
562 console. If the MI interpreter is not active, print nothing. */
564 /* Observer for the signal_received notification. */
567 mi_on_signal_received (enum gdb_signal siggnal
)
569 SWITCH_THRU_ALL_UIS ()
571 struct mi_interp
*mi
= find_mi_interp ();
576 print_signal_received_reason (mi
->mi_uiout
, siggnal
);
577 print_signal_received_reason (mi
->cli_uiout
, siggnal
);
581 /* Observer for the end_stepping_range notification. */
584 mi_on_end_stepping_range (void)
586 SWITCH_THRU_ALL_UIS ()
588 struct mi_interp
*mi
= find_mi_interp ();
593 print_end_stepping_range_reason (mi
->mi_uiout
);
594 print_end_stepping_range_reason (mi
->cli_uiout
);
598 /* Observer for the signal_exited notification. */
601 mi_on_signal_exited (enum gdb_signal siggnal
)
603 SWITCH_THRU_ALL_UIS ()
605 struct mi_interp
*mi
= find_mi_interp ();
610 print_signal_exited_reason (mi
->mi_uiout
, siggnal
);
611 print_signal_exited_reason (mi
->cli_uiout
, siggnal
);
615 /* Observer for the exited notification. */
618 mi_on_exited (int exitstatus
)
620 SWITCH_THRU_ALL_UIS ()
622 struct mi_interp
*mi
= find_mi_interp ();
627 print_exited_reason (mi
->mi_uiout
, exitstatus
);
628 print_exited_reason (mi
->cli_uiout
, exitstatus
);
632 /* Observer for the no_history notification. */
635 mi_on_no_history (void)
637 SWITCH_THRU_ALL_UIS ()
639 struct mi_interp
*mi
= find_mi_interp ();
644 print_no_history_reason (mi
->mi_uiout
);
645 print_no_history_reason (mi
->cli_uiout
);
650 mi_on_normal_stop_1 (struct bpstats
*bs
, int print_frame
)
652 /* Since this can be called when CLI command is executing,
653 using cli interpreter, be sure to use MI uiout for output,
654 not the current one. */
655 struct ui_out
*mi_uiout
= interp_ui_out (top_level_interpreter ());
656 struct mi_interp
*mi
= (struct mi_interp
*) top_level_interpreter ();
660 struct thread_info
*tp
;
662 struct interp
*console_interp
;
664 tp
= inferior_thread ();
666 if (tp
->thread_fsm
!= NULL
667 && thread_fsm_finished_p (tp
->thread_fsm
))
669 enum async_reply_reason reason
;
671 reason
= thread_fsm_async_reply_reason (tp
->thread_fsm
);
672 mi_uiout
->field_string ("reason", async_reason_lookup (reason
));
674 print_stop_event (mi_uiout
);
676 console_interp
= interp_lookup (current_ui
, INTERP_CONSOLE
);
677 if (should_print_stop_to_console (console_interp
, tp
))
678 print_stop_event (mi
->cli_uiout
);
680 mi_uiout
->field_int ("thread-id", tp
->global_num
);
683 struct cleanup
*back_to
= make_cleanup_ui_out_list_begin_end
684 (mi_uiout
, "stopped-threads");
686 mi_uiout
->field_int (NULL
, tp
->global_num
);
687 do_cleanups (back_to
);
690 mi_uiout
->field_string ("stopped-threads", "all");
692 core
= target_core_of_thread (inferior_ptid
);
694 mi_uiout
->field_int ("core", core
);
697 fputs_unfiltered ("*stopped", mi
->raw_stdout
);
698 mi_out_put (mi_uiout
, mi
->raw_stdout
);
699 mi_out_rewind (mi_uiout
);
700 mi_print_timing_maybe (mi
->raw_stdout
);
701 fputs_unfiltered ("\n", mi
->raw_stdout
);
702 gdb_flush (mi
->raw_stdout
);
706 mi_on_normal_stop (struct bpstats
*bs
, int print_frame
)
708 SWITCH_THRU_ALL_UIS ()
710 if (as_mi_interp (top_level_interpreter ()) == NULL
)
713 mi_on_normal_stop_1 (bs
, print_frame
);
718 mi_about_to_proceed (void)
720 /* Suppress output while calling an inferior function. */
722 if (!ptid_equal (inferior_ptid
, null_ptid
))
724 struct thread_info
*tp
= inferior_thread ();
726 if (tp
->control
.in_infcall
)
733 /* When the element is non-zero, no MI notifications will be emitted in
734 response to the corresponding observers. */
736 struct mi_suppress_notification mi_suppress_notification
=
744 /* Emit notification on changing a traceframe. */
747 mi_traceframe_changed (int tfnum
, int tpnum
)
749 if (mi_suppress_notification
.traceframe
)
752 SWITCH_THRU_ALL_UIS ()
754 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
755 struct cleanup
*old_chain
;
760 old_chain
= make_cleanup_restore_target_terminal ();
761 target_terminal_ours_for_output ();
764 fprintf_unfiltered (mi
->event_channel
, "traceframe-changed,"
765 "num=\"%d\",tracepoint=\"%d\"\n",
768 fprintf_unfiltered (mi
->event_channel
, "traceframe-changed,end");
770 gdb_flush (mi
->event_channel
);
772 do_cleanups (old_chain
);
776 /* Emit notification on creating a trace state variable. */
779 mi_tsv_created (const struct trace_state_variable
*tsv
)
781 SWITCH_THRU_ALL_UIS ()
783 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
784 struct cleanup
*old_chain
;
789 old_chain
= make_cleanup_restore_target_terminal ();
790 target_terminal_ours_for_output ();
792 fprintf_unfiltered (mi
->event_channel
, "tsv-created,"
793 "name=\"%s\",initial=\"%s\"\n",
794 tsv
->name
, plongest (tsv
->initial_value
));
796 gdb_flush (mi
->event_channel
);
798 do_cleanups (old_chain
);
802 /* Emit notification on deleting a trace state variable. */
805 mi_tsv_deleted (const struct trace_state_variable
*tsv
)
807 SWITCH_THRU_ALL_UIS ()
809 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
810 struct cleanup
*old_chain
;
815 old_chain
= make_cleanup_restore_target_terminal ();
816 target_terminal_ours_for_output ();
819 fprintf_unfiltered (mi
->event_channel
, "tsv-deleted,"
820 "name=\"%s\"\n", tsv
->name
);
822 fprintf_unfiltered (mi
->event_channel
, "tsv-deleted\n");
824 gdb_flush (mi
->event_channel
);
826 do_cleanups (old_chain
);
830 /* Emit notification on modifying a trace state variable. */
833 mi_tsv_modified (const struct trace_state_variable
*tsv
)
835 SWITCH_THRU_ALL_UIS ()
837 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
838 struct ui_out
*mi_uiout
;
839 struct cleanup
*old_chain
;
844 mi_uiout
= interp_ui_out (top_level_interpreter ());
846 old_chain
= make_cleanup_restore_target_terminal ();
847 target_terminal_ours_for_output ();
849 fprintf_unfiltered (mi
->event_channel
,
852 mi_uiout
->redirect (mi
->event_channel
);
854 mi_uiout
->field_string ("name", tsv
->name
);
855 mi_uiout
->field_string ("initial",
856 plongest (tsv
->initial_value
));
857 if (tsv
->value_known
)
858 mi_uiout
->field_string ("current", plongest (tsv
->value
));
860 mi_uiout
->redirect (NULL
);
862 gdb_flush (mi
->event_channel
);
864 do_cleanups (old_chain
);
868 /* Emit notification about a created breakpoint. */
871 mi_breakpoint_created (struct breakpoint
*b
)
873 if (mi_suppress_notification
.breakpoint
)
879 SWITCH_THRU_ALL_UIS ()
881 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
882 struct ui_out
*mi_uiout
;
883 struct cleanup
*old_chain
;
888 mi_uiout
= interp_ui_out (top_level_interpreter ());
890 old_chain
= make_cleanup_restore_target_terminal ();
891 target_terminal_ours_for_output ();
893 fprintf_unfiltered (mi
->event_channel
,
894 "breakpoint-created");
895 /* We want the output from gdb_breakpoint_query to go to
896 mi->event_channel. One approach would be to just call
897 gdb_breakpoint_query, and then use mi_out_put to send the current
898 content of mi_uiout into mi->event_channel. However, that will
899 break if anything is output to mi_uiout prior to calling the
900 breakpoint_created notifications. So, we use
902 mi_uiout
->redirect (mi
->event_channel
);
905 gdb_breakpoint_query (mi_uiout
, b
->number
, NULL
);
907 CATCH (e
, RETURN_MASK_ERROR
)
912 mi_uiout
->redirect (NULL
);
914 gdb_flush (mi
->event_channel
);
916 do_cleanups (old_chain
);
920 /* Emit notification about deleted breakpoint. */
923 mi_breakpoint_deleted (struct breakpoint
*b
)
925 if (mi_suppress_notification
.breakpoint
)
931 SWITCH_THRU_ALL_UIS ()
933 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
934 struct cleanup
*old_chain
;
939 old_chain
= make_cleanup_restore_target_terminal ();
940 target_terminal_ours_for_output ();
942 fprintf_unfiltered (mi
->event_channel
, "breakpoint-deleted,id=\"%d\"",
945 gdb_flush (mi
->event_channel
);
947 do_cleanups (old_chain
);
951 /* Emit notification about modified breakpoint. */
954 mi_breakpoint_modified (struct breakpoint
*b
)
956 if (mi_suppress_notification
.breakpoint
)
962 SWITCH_THRU_ALL_UIS ()
964 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
965 struct cleanup
*old_chain
;
970 old_chain
= make_cleanup_restore_target_terminal ();
971 target_terminal_ours_for_output ();
972 fprintf_unfiltered (mi
->event_channel
,
973 "breakpoint-modified");
974 /* We want the output from gdb_breakpoint_query to go to
975 mi->event_channel. One approach would be to just call
976 gdb_breakpoint_query, and then use mi_out_put to send the current
977 content of mi_uiout into mi->event_channel. However, that will
978 break if anything is output to mi_uiout prior to calling the
979 breakpoint_created notifications. So, we use
981 mi
->mi_uiout
->redirect (mi
->event_channel
);
984 gdb_breakpoint_query (mi
->mi_uiout
, b
->number
, NULL
);
986 CATCH (e
, RETURN_MASK_ERROR
)
991 mi
->mi_uiout
->redirect (NULL
);
993 gdb_flush (mi
->event_channel
);
995 do_cleanups (old_chain
);
1000 mi_output_running_pid (struct thread_info
*info
, void *arg
)
1002 ptid_t
*ptid
= (ptid_t
*) arg
;
1004 SWITCH_THRU_ALL_UIS ()
1006 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1011 if (ptid_get_pid (*ptid
) == ptid_get_pid (info
->ptid
))
1012 fprintf_unfiltered (mi
->raw_stdout
,
1013 "*running,thread-id=\"%d\"\n",
1021 mi_inferior_count (struct inferior
*inf
, void *arg
)
1025 int *count_p
= (int *) arg
;
1033 mi_on_resume_1 (struct mi_interp
*mi
, ptid_t ptid
)
1035 /* To cater for older frontends, emit ^running, but do it only once
1036 per each command. We do it here, since at this point we know
1037 that the target was successfully resumed, and in non-async mode,
1038 we won't return back to MI interpreter code until the target
1039 is done running, so delaying the output of "^running" until then
1040 will make it impossible for frontend to know what's going on.
1042 In future (MI3), we'll be outputting "^done" here. */
1043 if (!running_result_record_printed
&& mi_proceeded
)
1045 fprintf_unfiltered (mi
->raw_stdout
, "%s^running\n",
1046 current_token
? current_token
: "");
1049 if (ptid_get_pid (ptid
) == -1)
1050 fprintf_unfiltered (mi
->raw_stdout
, "*running,thread-id=\"all\"\n");
1051 else if (ptid_is_pid (ptid
))
1055 /* Backwards compatibility. If there's only one inferior,
1056 output "all", otherwise, output each resumed thread
1058 iterate_over_inferiors (mi_inferior_count
, &count
);
1061 fprintf_unfiltered (mi
->raw_stdout
, "*running,thread-id=\"all\"\n");
1063 iterate_over_threads (mi_output_running_pid
, &ptid
);
1067 struct thread_info
*ti
= find_thread_ptid (ptid
);
1070 fprintf_unfiltered (mi
->raw_stdout
, "*running,thread-id=\"%d\"\n",
1074 if (!running_result_record_printed
&& mi_proceeded
)
1076 running_result_record_printed
= 1;
1077 /* This is what gdb used to do historically -- printing prompt
1078 even if it cannot actually accept any input. This will be
1079 surely removed for MI3, and may be removed even earlier. */
1080 if (current_ui
->prompt_state
== PROMPT_BLOCKED
)
1081 fputs_unfiltered ("(gdb) \n", mi
->raw_stdout
);
1083 gdb_flush (mi
->raw_stdout
);
1087 mi_on_resume (ptid_t ptid
)
1089 struct thread_info
*tp
= NULL
;
1091 if (ptid_equal (ptid
, minus_one_ptid
) || ptid_is_pid (ptid
))
1092 tp
= inferior_thread ();
1094 tp
= find_thread_ptid (ptid
);
1096 /* Suppress output while calling an inferior function. */
1097 if (tp
->control
.in_infcall
)
1100 SWITCH_THRU_ALL_UIS ()
1102 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1103 struct cleanup
*old_chain
;
1108 old_chain
= make_cleanup_restore_target_terminal ();
1109 target_terminal_ours_for_output ();
1111 mi_on_resume_1 (mi
, ptid
);
1113 do_cleanups (old_chain
);
1117 /* See mi-interp.h. */
1120 mi_output_solib_attribs (ui_out
*uiout
, struct so_list
*solib
)
1122 struct gdbarch
*gdbarch
= target_gdbarch ();
1124 uiout
->field_string ("id", solib
->so_original_name
);
1125 uiout
->field_string ("target-name", solib
->so_original_name
);
1126 uiout
->field_string ("host-name", solib
->so_name
);
1127 uiout
->field_int ("symbols-loaded", solib
->symbols_loaded
);
1128 if (!gdbarch_has_global_solist (target_gdbarch ()))
1129 uiout
->field_fmt ("thread-group", "i%d", current_inferior ()->num
);
1131 struct cleanup
*cleanup
1132 = make_cleanup_ui_out_list_begin_end (uiout
, "ranges");
1133 struct cleanup
*tuple_clean_up
1134 = make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1135 if (solib
->addr_high
!= 0)
1137 uiout
->field_core_addr ("from", gdbarch
, solib
->addr_low
);
1138 uiout
->field_core_addr ("to", gdbarch
, solib
->addr_high
);
1140 do_cleanups (tuple_clean_up
);
1141 do_cleanups (cleanup
);
1145 mi_solib_loaded (struct so_list
*solib
)
1147 SWITCH_THRU_ALL_UIS ()
1149 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1150 struct ui_out
*uiout
;
1151 struct cleanup
*old_chain
;
1156 uiout
= interp_ui_out (top_level_interpreter ());
1158 old_chain
= make_cleanup_restore_target_terminal ();
1159 target_terminal_ours_for_output ();
1161 fprintf_unfiltered (mi
->event_channel
, "library-loaded");
1163 uiout
->redirect (mi
->event_channel
);
1165 mi_output_solib_attribs (uiout
, solib
);
1167 uiout
->redirect (NULL
);
1169 gdb_flush (mi
->event_channel
);
1171 do_cleanups (old_chain
);
1176 mi_solib_unloaded (struct so_list
*solib
)
1178 SWITCH_THRU_ALL_UIS ()
1180 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1181 struct ui_out
*uiout
;
1182 struct cleanup
*old_chain
;
1187 uiout
= interp_ui_out (top_level_interpreter ());
1189 old_chain
= make_cleanup_restore_target_terminal ();
1190 target_terminal_ours_for_output ();
1192 fprintf_unfiltered (mi
->event_channel
, "library-unloaded");
1194 uiout
->redirect (mi
->event_channel
);
1196 uiout
->field_string ("id", solib
->so_original_name
);
1197 uiout
->field_string ("target-name", solib
->so_original_name
);
1198 uiout
->field_string ("host-name", solib
->so_name
);
1199 if (!gdbarch_has_global_solist (target_gdbarch ()))
1201 uiout
->field_fmt ("thread-group", "i%d", current_inferior ()->num
);
1204 uiout
->redirect (NULL
);
1206 gdb_flush (mi
->event_channel
);
1208 do_cleanups (old_chain
);
1212 /* Emit notification about the command parameter change. */
1215 mi_command_param_changed (const char *param
, const char *value
)
1217 if (mi_suppress_notification
.cmd_param_changed
)
1220 SWITCH_THRU_ALL_UIS ()
1222 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1223 struct ui_out
*mi_uiout
;
1224 struct cleanup
*old_chain
;
1229 mi_uiout
= interp_ui_out (top_level_interpreter ());
1231 old_chain
= make_cleanup_restore_target_terminal ();
1232 target_terminal_ours_for_output ();
1234 fprintf_unfiltered (mi
->event_channel
, "cmd-param-changed");
1236 mi_uiout
->redirect (mi
->event_channel
);
1238 mi_uiout
->field_string ("param", param
);
1239 mi_uiout
->field_string ("value", value
);
1241 mi_uiout
->redirect (NULL
);
1243 gdb_flush (mi
->event_channel
);
1245 do_cleanups (old_chain
);
1249 /* Emit notification about the target memory change. */
1252 mi_memory_changed (struct inferior
*inferior
, CORE_ADDR memaddr
,
1253 ssize_t len
, const bfd_byte
*myaddr
)
1255 if (mi_suppress_notification
.memory
)
1258 SWITCH_THRU_ALL_UIS ()
1260 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1261 struct ui_out
*mi_uiout
;
1262 struct obj_section
*sec
;
1263 struct cleanup
*old_chain
;
1268 mi_uiout
= interp_ui_out (top_level_interpreter ());
1270 old_chain
= make_cleanup_restore_target_terminal ();
1271 target_terminal_ours_for_output ();
1273 fprintf_unfiltered (mi
->event_channel
, "memory-changed");
1275 mi_uiout
->redirect (mi
->event_channel
);
1277 mi_uiout
->field_fmt ("thread-group", "i%d", inferior
->num
);
1278 mi_uiout
->field_core_addr ("addr", target_gdbarch (), memaddr
);
1279 mi_uiout
->field_fmt ("len", "%s", hex_string (len
));
1281 /* Append 'type=code' into notification if MEMADDR falls in the range of
1282 sections contain code. */
1283 sec
= find_pc_section (memaddr
);
1284 if (sec
!= NULL
&& sec
->objfile
!= NULL
)
1286 flagword flags
= bfd_get_section_flags (sec
->objfile
->obfd
,
1287 sec
->the_bfd_section
);
1289 if (flags
& SEC_CODE
)
1290 mi_uiout
->field_string ("type", "code");
1293 mi_uiout
->redirect (NULL
);
1295 gdb_flush (mi
->event_channel
);
1297 do_cleanups (old_chain
);
1301 /* Emit an event when the selection context (inferior, thread, frame)
1305 mi_user_selected_context_changed (user_selected_what selection
)
1307 struct thread_info
*tp
;
1309 /* Don't send an event if we're responding to an MI command. */
1310 if (mi_suppress_notification
.user_selected_context
)
1313 tp
= find_thread_ptid (inferior_ptid
);
1315 SWITCH_THRU_ALL_UIS ()
1317 struct mi_interp
*mi
= as_mi_interp (top_level_interpreter ());
1318 struct ui_out
*mi_uiout
;
1319 struct cleanup
*old_chain
;
1324 mi_uiout
= interp_ui_out (top_level_interpreter ());
1326 mi_uiout
->redirect (mi
->event_channel
);
1328 old_chain
= make_cleanup_ui_out_redirect_pop (mi_uiout
);
1330 make_cleanup_restore_target_terminal ();
1331 target_terminal_ours_for_output ();
1333 if (selection
& USER_SELECTED_INFERIOR
)
1334 print_selected_inferior (mi
->cli_uiout
);
1337 && (selection
& (USER_SELECTED_THREAD
| USER_SELECTED_FRAME
)))
1339 print_selected_thread_frame (mi
->cli_uiout
, selection
);
1341 fprintf_unfiltered (mi
->event_channel
,
1342 "thread-selected,id=\"%d\"",
1345 if (tp
->state
!= THREAD_RUNNING
)
1347 if (has_stack_frames ())
1348 print_stack_frame_to_uiout (mi_uiout
, get_selected_frame (NULL
),
1353 gdb_flush (mi
->event_channel
);
1354 do_cleanups (old_chain
);
1359 report_initial_inferior (struct inferior
*inf
, void *closure
)
1361 /* This function is called from mi_interpreter_init, and since
1362 mi_inferior_added assumes that inferior is fully initialized
1363 and top_level_interpreter_data is set, we cannot call
1365 struct mi_interp
*mi
= (struct mi_interp
*) closure
;
1366 struct cleanup
*old_chain
;
1368 old_chain
= make_cleanup_restore_target_terminal ();
1369 target_terminal_ours_for_output ();
1371 fprintf_unfiltered (mi
->event_channel
,
1372 "thread-group-added,id=\"i%d\"",
1374 gdb_flush (mi
->event_channel
);
1376 do_cleanups (old_chain
);
1381 mi_interp::interp_ui_out ()
1383 return this->mi_uiout
;
1386 /* Do MI-specific logging actions; save raw_stdout, and change all
1387 the consoles to use the supplied ui-file(s). */
1390 mi_interp::set_logging (ui_file_up logfile
, bool logging_redirect
)
1392 struct mi_interp
*mi
= this;
1394 if (logfile
!= NULL
)
1396 mi
->saved_raw_stdout
= mi
->raw_stdout
;
1397 mi
->raw_stdout
= make_logging_output (mi
->raw_stdout
,
1398 std::move (logfile
),
1404 delete mi
->raw_stdout
;
1405 mi
->raw_stdout
= mi
->saved_raw_stdout
;
1406 mi
->saved_raw_stdout
= NULL
;
1409 mi
->out
->set_raw (mi
->raw_stdout
);
1410 mi
->err
->set_raw (mi
->raw_stdout
);
1411 mi
->log
->set_raw (mi
->raw_stdout
);
1412 mi
->targ
->set_raw (mi
->raw_stdout
);
1413 mi
->event_channel
->set_raw (mi
->raw_stdout
);
1416 /* Factory for MI interpreters. */
1418 static struct interp
*
1419 mi_interp_factory (const char *name
)
1421 return new mi_interp (name
);
1424 extern initialize_file_ftype _initialize_mi_interp
; /* -Wmissing-prototypes */
1427 _initialize_mi_interp (void)
1429 /* The various interpreter levels. */
1430 interp_factory_register (INTERP_MI1
, mi_interp_factory
);
1431 interp_factory_register (INTERP_MI2
, mi_interp_factory
);
1432 interp_factory_register (INTERP_MI3
, mi_interp_factory
);
1433 interp_factory_register (INTERP_MI
, mi_interp_factory
);
1435 observer_attach_signal_received (mi_on_signal_received
);
1436 observer_attach_end_stepping_range (mi_on_end_stepping_range
);
1437 observer_attach_signal_exited (mi_on_signal_exited
);
1438 observer_attach_exited (mi_on_exited
);
1439 observer_attach_no_history (mi_on_no_history
);
1440 observer_attach_new_thread (mi_new_thread
);
1441 observer_attach_thread_exit (mi_thread_exit
);
1442 observer_attach_inferior_added (mi_inferior_added
);
1443 observer_attach_inferior_appeared (mi_inferior_appeared
);
1444 observer_attach_inferior_exit (mi_inferior_exit
);
1445 observer_attach_inferior_removed (mi_inferior_removed
);
1446 observer_attach_record_changed (mi_record_changed
);
1447 observer_attach_normal_stop (mi_on_normal_stop
);
1448 observer_attach_target_resumed (mi_on_resume
);
1449 observer_attach_solib_loaded (mi_solib_loaded
);
1450 observer_attach_solib_unloaded (mi_solib_unloaded
);
1451 observer_attach_about_to_proceed (mi_about_to_proceed
);
1452 observer_attach_traceframe_changed (mi_traceframe_changed
);
1453 observer_attach_tsv_created (mi_tsv_created
);
1454 observer_attach_tsv_deleted (mi_tsv_deleted
);
1455 observer_attach_tsv_modified (mi_tsv_modified
);
1456 observer_attach_breakpoint_created (mi_breakpoint_created
);
1457 observer_attach_breakpoint_deleted (mi_breakpoint_deleted
);
1458 observer_attach_breakpoint_modified (mi_breakpoint_modified
);
1459 observer_attach_command_param_changed (mi_command_param_changed
);
1460 observer_attach_memory_changed (mi_memory_changed
);
1461 observer_attach_sync_execution_done (mi_on_sync_execution_done
);
1462 observer_attach_user_selected_context_changed
1463 (mi_user_selected_context_changed
);