1 /* MI Interpreter Definitions and Commands for GDB, the GNU debugger.
3 Copyright (C) 2002-2016 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 #include "event-top.h"
23 #include "event-loop.h"
31 #include "mi-console.h"
32 #include "mi-common.h"
34 #include "gdbthread.h"
38 #include "tracepoint.h"
40 #include "thread-fsm.h"
42 /* These are the interpreter setup, etc. functions for the MI
45 static void mi_execute_command_wrapper (const char *cmd
);
46 static void mi_execute_command_input_handler (char *cmd
);
47 static void mi_command_loop (void *data
);
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
);
93 mi_interpreter_init (struct interp
*interp
, int top_level
)
95 struct mi_interp
*mi
= XNEW (struct mi_interp
);
99 /* Assign the output channel created at startup to its own global,
100 so that we can create a console channel that encapsulates and
101 prefixes all gdb_output-type bits coming from the rest of the
104 raw_stdout
= gdb_stdout
;
106 /* Create MI console channels, each with a different prefix so they
107 can be distinguished. */
108 mi
->out
= mi_console_file_new (raw_stdout
, "~", '"');
109 mi
->err
= mi_console_file_new (raw_stdout
, "&", '"');
111 mi
->targ
= mi_console_file_new (raw_stdout
, "@", '"');
112 mi
->event_channel
= mi_console_file_new (raw_stdout
, "=", 0);
114 name
= interp_name (interp
);
115 /* INTERP_MI selects the most recent released version. "mi2" was
116 released as part of GDB 6.0. */
117 if (strcmp (name
, INTERP_MI
) == 0)
119 else if (strcmp (name
, INTERP_MI1
) == 0)
121 else if (strcmp (name
, INTERP_MI2
) == 0)
123 else if (strcmp (name
, INTERP_MI3
) == 0)
126 gdb_assert_not_reached ("unhandled MI version");
128 mi
->mi_uiout
= mi_out_new (mi_version
);
129 mi
->cli_uiout
= cli_out_new (mi
->out
);
131 /* There are installed even if MI is not the top level interpreter.
132 The callbacks themselves decide whether to be skipped. */
133 observer_attach_signal_received (mi_on_signal_received
);
134 observer_attach_end_stepping_range (mi_on_end_stepping_range
);
135 observer_attach_signal_exited (mi_on_signal_exited
);
136 observer_attach_exited (mi_on_exited
);
137 observer_attach_no_history (mi_on_no_history
);
141 observer_attach_new_thread (mi_new_thread
);
142 observer_attach_thread_exit (mi_thread_exit
);
143 observer_attach_inferior_added (mi_inferior_added
);
144 observer_attach_inferior_appeared (mi_inferior_appeared
);
145 observer_attach_inferior_exit (mi_inferior_exit
);
146 observer_attach_inferior_removed (mi_inferior_removed
);
147 observer_attach_record_changed (mi_record_changed
);
148 observer_attach_normal_stop (mi_on_normal_stop
);
149 observer_attach_target_resumed (mi_on_resume
);
150 observer_attach_solib_loaded (mi_solib_loaded
);
151 observer_attach_solib_unloaded (mi_solib_unloaded
);
152 observer_attach_about_to_proceed (mi_about_to_proceed
);
153 observer_attach_traceframe_changed (mi_traceframe_changed
);
154 observer_attach_tsv_created (mi_tsv_created
);
155 observer_attach_tsv_deleted (mi_tsv_deleted
);
156 observer_attach_tsv_modified (mi_tsv_modified
);
157 observer_attach_breakpoint_created (mi_breakpoint_created
);
158 observer_attach_breakpoint_deleted (mi_breakpoint_deleted
);
159 observer_attach_breakpoint_modified (mi_breakpoint_modified
);
160 observer_attach_command_param_changed (mi_command_param_changed
);
161 observer_attach_memory_changed (mi_memory_changed
);
162 observer_attach_sync_execution_done (mi_on_sync_execution_done
);
164 /* The initial inferior is created before this function is
165 called, so we need to report it explicitly. Use iteration in
166 case future version of GDB creates more than one inferior
168 iterate_over_inferiors (report_initial_inferior
, mi
);
175 mi_interpreter_resume (void *data
)
177 struct mi_interp
*mi
= (struct mi_interp
*) data
;
178 struct ui
*ui
= current_ui
;
180 /* As per hack note in mi_interpreter_init, swap in the output
182 gdb_setup_readline ();
184 /* These overwrite some of the initialization done in
185 _intialize_event_loop. */
186 ui
->call_readline
= gdb_readline_no_editing_callback
;
187 ui
->input_handler
= mi_execute_command_input_handler
;
188 async_command_editing_p
= 0;
189 /* FIXME: This is a total hack for now. PB's use of the MI
190 implicitly relies on a bug in the async support which allows
191 asynchronous commands to leak through the commmand loop. The bug
192 involves (but is not limited to) the fact that sync_execution was
193 erroneously initialized to 0. Duplicate by initializing it thus
197 gdb_stdout
= mi
->out
;
198 /* Route error and log output through the MI. */
199 gdb_stderr
= mi
->err
;
200 gdb_stdlog
= mi
->log
;
201 /* Route target output through the MI. */
202 gdb_stdtarg
= mi
->targ
;
203 /* Route target error through the MI as well. */
204 gdb_stdtargerr
= mi
->targ
;
206 /* Replace all the hooks that we know about. There really needs to
207 be a better way of doing this... */
208 clear_interpreter_hooks ();
210 deprecated_show_load_progress
= mi_load_progress
;
216 mi_interpreter_suspend (void *data
)
218 gdb_disable_readline ();
222 static struct gdb_exception
223 mi_interpreter_exec (void *data
, const char *command
)
225 mi_execute_command_wrapper (command
);
226 return exception_none
;
230 mi_cmd_interpreter_exec (char *command
, char **argv
, int argc
)
232 struct interp
*interp_to_use
;
234 char *mi_error_message
= NULL
;
235 struct cleanup
*old_chain
;
238 error (_("-interpreter-exec: "
239 "Usage: -interpreter-exec interp command"));
241 interp_to_use
= interp_lookup (current_ui
, argv
[0]);
242 if (interp_to_use
== NULL
)
243 error (_("-interpreter-exec: could not find interpreter \"%s\""),
246 /* Note that unlike the CLI version of this command, we don't
247 actually set INTERP_TO_USE as the current interpreter, as we
248 still want gdb_stdout, etc. to point at MI streams. */
250 /* Insert the MI out hooks, making sure to also call the
251 interpreter's hooks if it has any. */
252 /* KRS: We shouldn't need this... Events should be installed and
253 they should just ALWAYS fire something out down the MI
255 mi_insert_notify_hooks ();
257 /* Now run the code. */
259 old_chain
= make_cleanup (null_cleanup
, 0);
260 for (i
= 1; i
< argc
; i
++)
262 struct gdb_exception e
= interp_exec (interp_to_use
, argv
[i
]);
266 mi_error_message
= xstrdup (e
.message
);
267 make_cleanup (xfree
, mi_error_message
);
272 mi_remove_notify_hooks ();
274 if (mi_error_message
!= NULL
)
275 error ("%s", mi_error_message
);
276 do_cleanups (old_chain
);
279 /* This inserts a number of hooks that are meant to produce
280 async-notify ("=") MI messages while running commands in another
281 interpreter using mi_interpreter_exec. The canonical use for this
282 is to allow access to the gdb CLI interpreter from within the MI,
283 while still producing MI style output when actions in the CLI
284 command change GDB's state. */
287 mi_insert_notify_hooks (void)
289 deprecated_query_hook
= mi_interp_query_hook
;
293 mi_remove_notify_hooks (void)
295 deprecated_query_hook
= NULL
;
299 mi_interp_query_hook (const char *ctlstr
, va_list ap
)
305 mi_execute_command_wrapper (const char *cmd
)
307 mi_execute_command (cmd
, stdin
== instream
);
310 /* Observer for the synchronous_command_done notification. */
313 mi_on_sync_execution_done (void)
315 /* If MI is sync, then output the MI prompt now, indicating we're
316 ready for further input. */
319 fputs_unfiltered ("(gdb) \n", raw_stdout
);
320 gdb_flush (raw_stdout
);
324 /* mi_execute_command_wrapper wrapper suitable for INPUT_HANDLER. */
327 mi_execute_command_input_handler (char *cmd
)
329 mi_execute_command_wrapper (cmd
);
331 /* Print a prompt, indicating we're ready for further input, unless
332 we just started a synchronous command. In that case, we're about
333 to go back to the event loop and will output the prompt in the
334 'synchronous_command_done' observer when the target next
338 fputs_unfiltered ("(gdb) \n", raw_stdout
);
339 gdb_flush (raw_stdout
);
344 mi_command_loop (void *data
)
346 /* Turn off 8 bit strings in quoted output. Any character with the
347 high bit set is printed using C's octal format. */
348 sevenbit_strings
= 1;
350 /* Tell the world that we're alive. */
351 fputs_unfiltered ("(gdb) \n", raw_stdout
);
352 gdb_flush (raw_stdout
);
358 mi_new_thread (struct thread_info
*t
)
360 struct mi_interp
*mi
= (struct mi_interp
*) top_level_interpreter_data ();
361 struct inferior
*inf
= find_inferior_ptid (t
->ptid
);
362 struct cleanup
*old_chain
;
366 old_chain
= make_cleanup_restore_target_terminal ();
367 target_terminal_ours_for_output ();
369 fprintf_unfiltered (mi
->event_channel
,
370 "thread-created,id=\"%d\",group-id=\"i%d\"",
371 t
->global_num
, inf
->num
);
372 gdb_flush (mi
->event_channel
);
374 do_cleanups (old_chain
);
378 mi_thread_exit (struct thread_info
*t
, int silent
)
380 struct mi_interp
*mi
;
381 struct inferior
*inf
;
382 struct cleanup
*old_chain
;
387 inf
= find_inferior_ptid (t
->ptid
);
389 mi
= (struct mi_interp
*) top_level_interpreter_data ();
390 old_chain
= make_cleanup_restore_target_terminal ();
391 target_terminal_ours_for_output ();
393 fprintf_unfiltered (mi
->event_channel
,
394 "thread-exited,id=\"%d\",group-id=\"i%d\"",
395 t
->global_num
, inf
->num
);
396 gdb_flush (mi
->event_channel
);
398 do_cleanups (old_chain
);
401 /* Emit notification on changing the state of record. */
404 mi_record_changed (struct inferior
*inferior
, int started
, const char *method
,
407 struct mi_interp
*mi
= (struct mi_interp
*) top_level_interpreter_data ();
408 struct cleanup
*old_chain
;
410 old_chain
= make_cleanup_restore_target_terminal ();
411 target_terminal_ours_for_output ();
419 "record-started,thread-group=\"i%d\",method=\"%s\",format=\"%s\"",
420 inferior
->num
, method
, format
);
426 "record-started,thread-group=\"i%d\",method=\"%s\"",
427 inferior
->num
, method
);
432 fprintf_unfiltered (mi
->event_channel
,
433 "record-stopped,thread-group=\"i%d\"", inferior
->num
);
437 gdb_flush (mi
->event_channel
);
439 do_cleanups (old_chain
);
443 mi_inferior_added (struct inferior
*inf
)
445 struct mi_interp
*mi
= (struct mi_interp
*) top_level_interpreter_data ();
446 struct cleanup
*old_chain
;
448 old_chain
= make_cleanup_restore_target_terminal ();
449 target_terminal_ours_for_output ();
451 fprintf_unfiltered (mi
->event_channel
,
452 "thread-group-added,id=\"i%d\"",
454 gdb_flush (mi
->event_channel
);
456 do_cleanups (old_chain
);
460 mi_inferior_appeared (struct inferior
*inf
)
462 struct mi_interp
*mi
= (struct mi_interp
*) top_level_interpreter_data ();
463 struct cleanup
*old_chain
;
465 old_chain
= make_cleanup_restore_target_terminal ();
466 target_terminal_ours_for_output ();
468 fprintf_unfiltered (mi
->event_channel
,
469 "thread-group-started,id=\"i%d\",pid=\"%d\"",
471 gdb_flush (mi
->event_channel
);
473 do_cleanups (old_chain
);
477 mi_inferior_exit (struct inferior
*inf
)
479 struct mi_interp
*mi
= (struct mi_interp
*) top_level_interpreter_data ();
480 struct cleanup
*old_chain
;
482 old_chain
= make_cleanup_restore_target_terminal ();
483 target_terminal_ours_for_output ();
485 if (inf
->has_exit_code
)
486 fprintf_unfiltered (mi
->event_channel
,
487 "thread-group-exited,id=\"i%d\",exit-code=\"%s\"",
488 inf
->num
, int_string (inf
->exit_code
, 8, 0, 0, 1));
490 fprintf_unfiltered (mi
->event_channel
,
491 "thread-group-exited,id=\"i%d\"", inf
->num
);
492 gdb_flush (mi
->event_channel
);
494 do_cleanups (old_chain
);
498 mi_inferior_removed (struct inferior
*inf
)
500 struct mi_interp
*mi
= (struct mi_interp
*) top_level_interpreter_data ();
501 struct cleanup
*old_chain
;
503 old_chain
= make_cleanup_restore_target_terminal ();
504 target_terminal_ours_for_output ();
506 fprintf_unfiltered (mi
->event_channel
,
507 "thread-group-removed,id=\"i%d\"",
509 gdb_flush (mi
->event_channel
);
511 do_cleanups (old_chain
);
514 /* Return the MI interpreter, if it is active -- either because it's
515 the top-level interpreter or the interpreter executing the current
516 command. Returns NULL if the MI interpreter is not being used. */
518 static struct interp
*
519 find_mi_interpreter (void)
521 struct interp
*interp
;
523 interp
= top_level_interpreter ();
524 if (ui_out_is_mi_like_p (interp_ui_out (interp
)))
527 interp
= command_interp ();
528 if (ui_out_is_mi_like_p (interp_ui_out (interp
)))
534 /* Return the MI_INTERP structure of the active MI interpreter.
535 Returns NULL if MI is not active. */
537 static struct mi_interp
*
538 mi_interp_data (void)
540 struct interp
*interp
= find_mi_interpreter ();
543 return (struct mi_interp
*) interp_data (interp
);
547 /* Observers for several run control events that print why the
548 inferior has stopped to both the the MI event channel and to the MI
549 console. If the MI interpreter is not active, print nothing. */
551 /* Observer for the signal_received notification. */
554 mi_on_signal_received (enum gdb_signal siggnal
)
556 struct mi_interp
*mi
= mi_interp_data ();
561 print_signal_received_reason (mi
->mi_uiout
, siggnal
);
562 print_signal_received_reason (mi
->cli_uiout
, siggnal
);
565 /* Observer for the end_stepping_range notification. */
568 mi_on_end_stepping_range (void)
570 struct mi_interp
*mi
= mi_interp_data ();
575 print_end_stepping_range_reason (mi
->mi_uiout
);
576 print_end_stepping_range_reason (mi
->cli_uiout
);
579 /* Observer for the signal_exited notification. */
582 mi_on_signal_exited (enum gdb_signal siggnal
)
584 struct mi_interp
*mi
= mi_interp_data ();
589 print_signal_exited_reason (mi
->mi_uiout
, siggnal
);
590 print_signal_exited_reason (mi
->cli_uiout
, siggnal
);
593 /* Observer for the exited notification. */
596 mi_on_exited (int exitstatus
)
598 struct mi_interp
*mi
= mi_interp_data ();
603 print_exited_reason (mi
->mi_uiout
, exitstatus
);
604 print_exited_reason (mi
->cli_uiout
, exitstatus
);
607 /* Observer for the no_history notification. */
610 mi_on_no_history (void)
612 struct mi_interp
*mi
= mi_interp_data ();
617 print_no_history_reason (mi
->mi_uiout
);
618 print_no_history_reason (mi
->cli_uiout
);
622 mi_on_normal_stop (struct bpstats
*bs
, int print_frame
)
624 /* Since this can be called when CLI command is executing,
625 using cli interpreter, be sure to use MI uiout for output,
626 not the current one. */
627 struct ui_out
*mi_uiout
= interp_ui_out (top_level_interpreter ());
631 struct thread_info
*tp
;
634 tp
= inferior_thread ();
636 if (tp
->thread_fsm
!= NULL
637 && thread_fsm_finished_p (tp
->thread_fsm
))
639 enum async_reply_reason reason
;
641 reason
= thread_fsm_async_reply_reason (tp
->thread_fsm
);
642 ui_out_field_string (mi_uiout
, "reason",
643 async_reason_lookup (reason
));
645 print_stop_event (mi_uiout
);
647 /* Breakpoint hits should always be mirrored to the console.
648 Deciding what to mirror to the console wrt to breakpoints and
649 random stops gets messy real fast. E.g., say "s" trips on a
650 breakpoint. We'd clearly want to mirror the event to the
651 console in this case. But what about more complicated cases
652 like "s&; thread n; s&", and one of those steps spawning a
653 new thread, and that thread hitting a breakpoint? It's
654 impossible in general to track whether the thread had any
655 relation to the commands that had been executed. So we just
656 simplify and always mirror breakpoints and random events to
659 OTOH, we should print the source line to the console when
660 stepping or other similar commands, iff the step was started
661 by a console command, but not if it was started with
662 -exec-step or similar. */
663 if ((bpstat_what (tp
->control
.stop_bpstat
).main_action
664 == BPSTAT_WHAT_STOP_NOISY
)
665 || !(tp
->thread_fsm
!= NULL
666 && thread_fsm_finished_p (tp
->thread_fsm
))
667 || (tp
->control
.command_interp
!= NULL
668 && tp
->control
.command_interp
!= top_level_interpreter ()))
671 = (struct mi_interp
*) top_level_interpreter_data ();
673 print_stop_event (mi
->cli_uiout
);
676 tp
= inferior_thread ();
677 ui_out_field_int (mi_uiout
, "thread-id", tp
->global_num
);
680 struct cleanup
*back_to
= make_cleanup_ui_out_list_begin_end
681 (mi_uiout
, "stopped-threads");
683 ui_out_field_int (mi_uiout
, NULL
, tp
->global_num
);
684 do_cleanups (back_to
);
687 ui_out_field_string (mi_uiout
, "stopped-threads", "all");
689 core
= target_core_of_thread (inferior_ptid
);
691 ui_out_field_int (mi_uiout
, "core", core
);
694 fputs_unfiltered ("*stopped", raw_stdout
);
695 mi_out_put (mi_uiout
, raw_stdout
);
696 mi_out_rewind (mi_uiout
);
697 mi_print_timing_maybe ();
698 fputs_unfiltered ("\n", raw_stdout
);
699 gdb_flush (raw_stdout
);
703 mi_about_to_proceed (void)
705 /* Suppress output while calling an inferior function. */
707 if (!ptid_equal (inferior_ptid
, null_ptid
))
709 struct thread_info
*tp
= inferior_thread ();
711 if (tp
->control
.in_infcall
)
718 /* When the element is non-zero, no MI notifications will be emitted in
719 response to the corresponding observers. */
721 struct mi_suppress_notification mi_suppress_notification
=
728 /* Emit notification on changing a traceframe. */
731 mi_traceframe_changed (int tfnum
, int tpnum
)
733 struct mi_interp
*mi
= (struct mi_interp
*) top_level_interpreter_data ();
734 struct cleanup
*old_chain
;
736 if (mi_suppress_notification
.traceframe
)
739 old_chain
= make_cleanup_restore_target_terminal ();
740 target_terminal_ours_for_output ();
743 fprintf_unfiltered (mi
->event_channel
, "traceframe-changed,"
744 "num=\"%d\",tracepoint=\"%d\"\n",
747 fprintf_unfiltered (mi
->event_channel
, "traceframe-changed,end");
749 gdb_flush (mi
->event_channel
);
751 do_cleanups (old_chain
);
754 /* Emit notification on creating a trace state variable. */
757 mi_tsv_created (const struct trace_state_variable
*tsv
)
759 struct mi_interp
*mi
= (struct mi_interp
*) top_level_interpreter_data ();
760 struct cleanup
*old_chain
;
762 old_chain
= make_cleanup_restore_target_terminal ();
763 target_terminal_ours_for_output ();
765 fprintf_unfiltered (mi
->event_channel
, "tsv-created,"
766 "name=\"%s\",initial=\"%s\"\n",
767 tsv
->name
, plongest (tsv
->initial_value
));
769 gdb_flush (mi
->event_channel
);
771 do_cleanups (old_chain
);
774 /* Emit notification on deleting a trace state variable. */
777 mi_tsv_deleted (const struct trace_state_variable
*tsv
)
779 struct mi_interp
*mi
= (struct mi_interp
*) top_level_interpreter_data ();
780 struct cleanup
*old_chain
;
782 old_chain
= make_cleanup_restore_target_terminal ();
783 target_terminal_ours_for_output ();
786 fprintf_unfiltered (mi
->event_channel
, "tsv-deleted,"
787 "name=\"%s\"\n", tsv
->name
);
789 fprintf_unfiltered (mi
->event_channel
, "tsv-deleted\n");
791 gdb_flush (mi
->event_channel
);
793 do_cleanups (old_chain
);
796 /* Emit notification on modifying a trace state variable. */
799 mi_tsv_modified (const struct trace_state_variable
*tsv
)
801 struct mi_interp
*mi
= (struct mi_interp
*) top_level_interpreter_data ();
802 struct ui_out
*mi_uiout
= interp_ui_out (top_level_interpreter ());
803 struct cleanup
*old_chain
;
805 old_chain
= make_cleanup_restore_target_terminal ();
806 target_terminal_ours_for_output ();
808 fprintf_unfiltered (mi
->event_channel
,
811 ui_out_redirect (mi_uiout
, mi
->event_channel
);
813 ui_out_field_string (mi_uiout
, "name", tsv
->name
);
814 ui_out_field_string (mi_uiout
, "initial",
815 plongest (tsv
->initial_value
));
816 if (tsv
->value_known
)
817 ui_out_field_string (mi_uiout
, "current", plongest (tsv
->value
));
819 ui_out_redirect (mi_uiout
, NULL
);
821 gdb_flush (mi
->event_channel
);
823 do_cleanups (old_chain
);
826 /* Emit notification about a created breakpoint. */
829 mi_breakpoint_created (struct breakpoint
*b
)
831 struct mi_interp
*mi
= (struct mi_interp
*) top_level_interpreter_data ();
832 struct ui_out
*mi_uiout
= interp_ui_out (top_level_interpreter ());
833 struct cleanup
*old_chain
;
835 if (mi_suppress_notification
.breakpoint
)
841 old_chain
= make_cleanup_restore_target_terminal ();
842 target_terminal_ours_for_output ();
844 fprintf_unfiltered (mi
->event_channel
,
845 "breakpoint-created");
846 /* We want the output from gdb_breakpoint_query to go to
847 mi->event_channel. One approach would be to just call
848 gdb_breakpoint_query, and then use mi_out_put to send the current
849 content of mi_outout into mi->event_channel. However, that will
850 break if anything is output to mi_uiout prior to calling the
851 breakpoint_created notifications. So, we use
853 ui_out_redirect (mi_uiout
, mi
->event_channel
);
856 gdb_breakpoint_query (mi_uiout
, b
->number
, NULL
);
858 CATCH (e
, RETURN_MASK_ERROR
)
863 ui_out_redirect (mi_uiout
, NULL
);
865 gdb_flush (mi
->event_channel
);
867 do_cleanups (old_chain
);
870 /* Emit notification about deleted breakpoint. */
873 mi_breakpoint_deleted (struct breakpoint
*b
)
875 struct mi_interp
*mi
= (struct mi_interp
*) top_level_interpreter_data ();
876 struct cleanup
*old_chain
;
878 if (mi_suppress_notification
.breakpoint
)
884 old_chain
= make_cleanup_restore_target_terminal ();
885 target_terminal_ours_for_output ();
887 fprintf_unfiltered (mi
->event_channel
, "breakpoint-deleted,id=\"%d\"",
890 gdb_flush (mi
->event_channel
);
892 do_cleanups (old_chain
);
895 /* Emit notification about modified breakpoint. */
898 mi_breakpoint_modified (struct breakpoint
*b
)
900 struct mi_interp
*mi
= (struct mi_interp
*) top_level_interpreter_data ();
901 struct ui_out
*mi_uiout
= interp_ui_out (top_level_interpreter ());
902 struct cleanup
*old_chain
;
904 if (mi_suppress_notification
.breakpoint
)
910 old_chain
= make_cleanup_restore_target_terminal ();
911 target_terminal_ours_for_output ();
913 fprintf_unfiltered (mi
->event_channel
,
914 "breakpoint-modified");
915 /* We want the output from gdb_breakpoint_query to go to
916 mi->event_channel. One approach would be to just call
917 gdb_breakpoint_query, and then use mi_out_put to send the current
918 content of mi_outout into mi->event_channel. However, that will
919 break if anything is output to mi_uiout prior to calling the
920 breakpoint_created notifications. So, we use
922 ui_out_redirect (mi_uiout
, mi
->event_channel
);
925 gdb_breakpoint_query (mi_uiout
, b
->number
, NULL
);
927 CATCH (e
, RETURN_MASK_ERROR
)
932 ui_out_redirect (mi_uiout
, NULL
);
934 gdb_flush (mi
->event_channel
);
936 do_cleanups (old_chain
);
940 mi_output_running_pid (struct thread_info
*info
, void *arg
)
942 ptid_t
*ptid
= (ptid_t
*) arg
;
944 if (ptid_get_pid (*ptid
) == ptid_get_pid (info
->ptid
))
945 fprintf_unfiltered (raw_stdout
,
946 "*running,thread-id=\"%d\"\n",
953 mi_inferior_count (struct inferior
*inf
, void *arg
)
957 int *count_p
= (int *) arg
;
965 mi_on_resume (ptid_t ptid
)
967 struct thread_info
*tp
= NULL
;
969 if (ptid_equal (ptid
, minus_one_ptid
) || ptid_is_pid (ptid
))
970 tp
= inferior_thread ();
972 tp
= find_thread_ptid (ptid
);
974 /* Suppress output while calling an inferior function. */
975 if (tp
->control
.in_infcall
)
978 /* To cater for older frontends, emit ^running, but do it only once
979 per each command. We do it here, since at this point we know
980 that the target was successfully resumed, and in non-async mode,
981 we won't return back to MI interpreter code until the target
982 is done running, so delaying the output of "^running" until then
983 will make it impossible for frontend to know what's going on.
985 In future (MI3), we'll be outputting "^done" here. */
986 if (!running_result_record_printed
&& mi_proceeded
)
988 fprintf_unfiltered (raw_stdout
, "%s^running\n",
989 current_token
? current_token
: "");
992 if (ptid_get_pid (ptid
) == -1)
993 fprintf_unfiltered (raw_stdout
, "*running,thread-id=\"all\"\n");
994 else if (ptid_is_pid (ptid
))
998 /* Backwards compatibility. If there's only one inferior,
999 output "all", otherwise, output each resumed thread
1001 iterate_over_inferiors (mi_inferior_count
, &count
);
1004 fprintf_unfiltered (raw_stdout
, "*running,thread-id=\"all\"\n");
1006 iterate_over_threads (mi_output_running_pid
, &ptid
);
1010 struct thread_info
*ti
= find_thread_ptid (ptid
);
1013 fprintf_unfiltered (raw_stdout
, "*running,thread-id=\"%d\"\n",
1017 if (!running_result_record_printed
&& mi_proceeded
)
1019 running_result_record_printed
= 1;
1020 /* This is what gdb used to do historically -- printing prompt even if
1021 it cannot actually accept any input. This will be surely removed
1022 for MI3, and may be removed even earlier. SYNC_EXECUTION is
1023 checked here because we only need to emit a prompt if a
1024 synchronous command was issued when the target is async. */
1025 if (!target_can_async_p () || sync_execution
)
1026 fputs_unfiltered ("(gdb) \n", raw_stdout
);
1028 gdb_flush (raw_stdout
);
1032 mi_solib_loaded (struct so_list
*solib
)
1034 struct mi_interp
*mi
= (struct mi_interp
*) top_level_interpreter_data ();
1035 struct ui_out
*uiout
= interp_ui_out (top_level_interpreter ());
1036 struct cleanup
*old_chain
;
1038 old_chain
= make_cleanup_restore_target_terminal ();
1039 target_terminal_ours_for_output ();
1041 fprintf_unfiltered (mi
->event_channel
, "library-loaded");
1043 ui_out_redirect (uiout
, mi
->event_channel
);
1045 ui_out_field_string (uiout
, "id", solib
->so_original_name
);
1046 ui_out_field_string (uiout
, "target-name", solib
->so_original_name
);
1047 ui_out_field_string (uiout
, "host-name", solib
->so_name
);
1048 ui_out_field_int (uiout
, "symbols-loaded", solib
->symbols_loaded
);
1049 if (!gdbarch_has_global_solist (target_gdbarch ()))
1051 ui_out_field_fmt (uiout
, "thread-group", "i%d",
1052 current_inferior ()->num
);
1055 ui_out_redirect (uiout
, NULL
);
1057 gdb_flush (mi
->event_channel
);
1059 do_cleanups (old_chain
);
1063 mi_solib_unloaded (struct so_list
*solib
)
1065 struct mi_interp
*mi
= (struct mi_interp
*) top_level_interpreter_data ();
1066 struct ui_out
*uiout
= interp_ui_out (top_level_interpreter ());
1067 struct cleanup
*old_chain
;
1069 old_chain
= make_cleanup_restore_target_terminal ();
1070 target_terminal_ours_for_output ();
1072 fprintf_unfiltered (mi
->event_channel
, "library-unloaded");
1074 ui_out_redirect (uiout
, mi
->event_channel
);
1076 ui_out_field_string (uiout
, "id", solib
->so_original_name
);
1077 ui_out_field_string (uiout
, "target-name", solib
->so_original_name
);
1078 ui_out_field_string (uiout
, "host-name", solib
->so_name
);
1079 if (!gdbarch_has_global_solist (target_gdbarch ()))
1081 ui_out_field_fmt (uiout
, "thread-group", "i%d",
1082 current_inferior ()->num
);
1085 ui_out_redirect (uiout
, NULL
);
1087 gdb_flush (mi
->event_channel
);
1089 do_cleanups (old_chain
);
1092 /* Emit notification about the command parameter change. */
1095 mi_command_param_changed (const char *param
, const char *value
)
1097 struct mi_interp
*mi
= (struct mi_interp
*) top_level_interpreter_data ();
1098 struct ui_out
*mi_uiout
= interp_ui_out (top_level_interpreter ());
1099 struct cleanup
*old_chain
;
1101 if (mi_suppress_notification
.cmd_param_changed
)
1104 old_chain
= make_cleanup_restore_target_terminal ();
1105 target_terminal_ours_for_output ();
1107 fprintf_unfiltered (mi
->event_channel
,
1108 "cmd-param-changed");
1110 ui_out_redirect (mi_uiout
, mi
->event_channel
);
1112 ui_out_field_string (mi_uiout
, "param", param
);
1113 ui_out_field_string (mi_uiout
, "value", value
);
1115 ui_out_redirect (mi_uiout
, NULL
);
1117 gdb_flush (mi
->event_channel
);
1119 do_cleanups (old_chain
);
1122 /* Emit notification about the target memory change. */
1125 mi_memory_changed (struct inferior
*inferior
, CORE_ADDR memaddr
,
1126 ssize_t len
, const bfd_byte
*myaddr
)
1128 struct mi_interp
*mi
= (struct mi_interp
*) top_level_interpreter_data ();
1129 struct ui_out
*mi_uiout
= interp_ui_out (top_level_interpreter ());
1130 struct obj_section
*sec
;
1131 struct cleanup
*old_chain
;
1133 if (mi_suppress_notification
.memory
)
1136 old_chain
= make_cleanup_restore_target_terminal ();
1137 target_terminal_ours_for_output ();
1139 fprintf_unfiltered (mi
->event_channel
,
1142 ui_out_redirect (mi_uiout
, mi
->event_channel
);
1144 ui_out_field_fmt (mi_uiout
, "thread-group", "i%d", inferior
->num
);
1145 ui_out_field_core_addr (mi_uiout
, "addr", target_gdbarch (), memaddr
);
1146 ui_out_field_fmt (mi_uiout
, "len", "%s", hex_string (len
));
1148 /* Append 'type=code' into notification if MEMADDR falls in the range of
1149 sections contain code. */
1150 sec
= find_pc_section (memaddr
);
1151 if (sec
!= NULL
&& sec
->objfile
!= NULL
)
1153 flagword flags
= bfd_get_section_flags (sec
->objfile
->obfd
,
1154 sec
->the_bfd_section
);
1156 if (flags
& SEC_CODE
)
1157 ui_out_field_string (mi_uiout
, "type", "code");
1160 ui_out_redirect (mi_uiout
, NULL
);
1162 gdb_flush (mi
->event_channel
);
1164 do_cleanups (old_chain
);
1168 report_initial_inferior (struct inferior
*inf
, void *closure
)
1170 /* This function is called from mi_intepreter_init, and since
1171 mi_inferior_added assumes that inferior is fully initialized
1172 and top_level_interpreter_data is set, we cannot call
1174 struct mi_interp
*mi
= (struct mi_interp
*) closure
;
1175 struct cleanup
*old_chain
;
1177 old_chain
= make_cleanup_restore_target_terminal ();
1178 target_terminal_ours_for_output ();
1180 fprintf_unfiltered (mi
->event_channel
,
1181 "thread-group-added,id=\"i%d\"",
1183 gdb_flush (mi
->event_channel
);
1185 do_cleanups (old_chain
);
1189 static struct ui_out
*
1190 mi_ui_out (struct interp
*interp
)
1192 struct mi_interp
*mi
= (struct mi_interp
*) interp_data (interp
);
1194 return mi
->mi_uiout
;
1197 /* Save the original value of raw_stdout here when logging, so we can
1198 restore correctly when done. */
1200 static struct ui_file
*saved_raw_stdout
;
1202 /* Do MI-specific logging actions; save raw_stdout, and change all
1203 the consoles to use the supplied ui-file(s). */
1206 mi_set_logging (struct interp
*interp
, int start_log
,
1207 struct ui_file
*out
, struct ui_file
*logfile
)
1209 struct mi_interp
*mi
= (struct mi_interp
*) interp_data (interp
);
1216 /* The tee created already is based on gdb_stdout, which for MI
1217 is a console and so we end up in an infinite loop of console
1218 writing to ui_file writing to console etc. So discard the
1219 existing tee (it hasn't been used yet, and MI won't ever use
1220 it), and create one based on raw_stdout instead. */
1223 ui_file_delete (out
);
1224 out
= tee_file_new (raw_stdout
, 0, logfile
, 0);
1227 saved_raw_stdout
= raw_stdout
;
1232 raw_stdout
= saved_raw_stdout
;
1233 saved_raw_stdout
= NULL
;
1236 mi_console_set_raw (mi
->out
, raw_stdout
);
1237 mi_console_set_raw (mi
->err
, raw_stdout
);
1238 mi_console_set_raw (mi
->log
, raw_stdout
);
1239 mi_console_set_raw (mi
->targ
, raw_stdout
);
1240 mi_console_set_raw (mi
->event_channel
, raw_stdout
);
1245 /* The MI interpreter's vtable. */
1247 static const struct interp_procs mi_interp_procs
=
1249 mi_interpreter_init
, /* init_proc */
1250 mi_interpreter_resume
, /* resume_proc */
1251 mi_interpreter_suspend
, /* suspend_proc */
1252 mi_interpreter_exec
, /* exec_proc */
1253 mi_ui_out
, /* ui_out_proc */
1254 mi_set_logging
, /* set_logging_proc */
1255 mi_command_loop
/* command_loop_proc */
1258 /* Factory for MI interpreters. */
1260 static struct interp
*
1261 mi_interp_factory (const char *name
)
1263 return interp_new (name
, &mi_interp_procs
, NULL
);
1266 extern initialize_file_ftype _initialize_mi_interp
; /* -Wmissing-prototypes */
1269 _initialize_mi_interp (void)
1271 /* The various interpreter levels. */
1272 interp_factory_register (INTERP_MI1
, mi_interp_factory
);
1273 interp_factory_register (INTERP_MI2
, mi_interp_factory
);
1274 interp_factory_register (INTERP_MI3
, mi_interp_factory
);
1275 interp_factory_register (INTERP_MI
, mi_interp_factory
);