1 /* MI Interpreter Definitions and Commands for GDB, the GNU debugger.
3 Copyright (C) 2002-2014 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/>. */
23 #include "event-top.h"
24 #include "event-loop.h"
29 #include "exceptions.h"
33 #include "mi-console.h"
34 #include "mi-common.h"
36 #include "gdbthread.h"
40 #include "tracepoint.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
);
48 static void mi_command_loop (void *data
);
50 /* These are hooks that we put in place while doing interpreter_exec
51 so we can report interesting things that happened "behind the MI's
52 back" in this command. */
54 static int mi_interp_query_hook (const char *ctlstr
, va_list ap
)
55 ATTRIBUTE_PRINTF (1, 0);
57 static void mi_insert_notify_hooks (void);
58 static void mi_remove_notify_hooks (void);
60 static void mi_on_signal_received (enum gdb_signal siggnal
);
61 static void mi_on_end_stepping_range (void);
62 static void mi_on_signal_exited (enum gdb_signal siggnal
);
63 static void mi_on_exited (int exitstatus
);
64 static void mi_on_normal_stop (struct bpstats
*bs
, int print_frame
);
65 static void mi_on_no_history (void);
67 static void mi_new_thread (struct thread_info
*t
);
68 static void mi_thread_exit (struct thread_info
*t
, int silent
);
69 static void mi_record_changed (struct inferior
*, int);
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
);
89 static int report_initial_inferior (struct inferior
*inf
, void *closure
);
92 mi_interpreter_init (struct interp
*interp
, int top_level
)
94 struct mi_interp
*mi
= XNEW (struct mi_interp
);
98 /* Assign the output channel created at startup to its own global,
99 so that we can create a console channel that encapsulates and
100 prefixes all gdb_output-type bits coming from the rest of the
103 raw_stdout
= gdb_stdout
;
105 /* Create MI console channels, each with a different prefix so they
106 can be distinguished. */
107 mi
->out
= mi_console_file_new (raw_stdout
, "~", '"');
108 mi
->err
= mi_console_file_new (raw_stdout
, "&", '"');
110 mi
->targ
= mi_console_file_new (raw_stdout
, "@", '"');
111 mi
->event_channel
= mi_console_file_new (raw_stdout
, "=", 0);
113 name
= interp_name (interp
);
114 /* INTERP_MI selects the most recent released version. "mi2" was
115 released as part of GDB 6.0. */
116 if (strcmp (name
, INTERP_MI
) == 0)
118 else if (strcmp (name
, INTERP_MI1
) == 0)
120 else if (strcmp (name
, INTERP_MI2
) == 0)
122 else if (strcmp (name
, INTERP_MI3
) == 0)
125 gdb_assert_not_reached ("unhandled MI version");
127 mi
->mi_uiout
= mi_out_new (mi_version
);
128 mi
->cli_uiout
= cli_out_new (mi
->out
);
130 /* There are installed even if MI is not the top level interpreter.
131 The callbacks themselves decide whether to be skipped. */
132 observer_attach_signal_received (mi_on_signal_received
);
133 observer_attach_end_stepping_range (mi_on_end_stepping_range
);
134 observer_attach_signal_exited (mi_on_signal_exited
);
135 observer_attach_exited (mi_on_exited
);
136 observer_attach_no_history (mi_on_no_history
);
140 observer_attach_new_thread (mi_new_thread
);
141 observer_attach_thread_exit (mi_thread_exit
);
142 observer_attach_inferior_added (mi_inferior_added
);
143 observer_attach_inferior_appeared (mi_inferior_appeared
);
144 observer_attach_inferior_exit (mi_inferior_exit
);
145 observer_attach_inferior_removed (mi_inferior_removed
);
146 observer_attach_record_changed (mi_record_changed
);
147 observer_attach_normal_stop (mi_on_normal_stop
);
148 observer_attach_target_resumed (mi_on_resume
);
149 observer_attach_solib_loaded (mi_solib_loaded
);
150 observer_attach_solib_unloaded (mi_solib_unloaded
);
151 observer_attach_about_to_proceed (mi_about_to_proceed
);
152 observer_attach_traceframe_changed (mi_traceframe_changed
);
153 observer_attach_tsv_created (mi_tsv_created
);
154 observer_attach_tsv_deleted (mi_tsv_deleted
);
155 observer_attach_tsv_modified (mi_tsv_modified
);
156 observer_attach_breakpoint_created (mi_breakpoint_created
);
157 observer_attach_breakpoint_deleted (mi_breakpoint_deleted
);
158 observer_attach_breakpoint_modified (mi_breakpoint_modified
);
159 observer_attach_command_param_changed (mi_command_param_changed
);
160 observer_attach_memory_changed (mi_memory_changed
);
162 /* The initial inferior is created before this function is
163 called, so we need to report it explicitly. Use iteration in
164 case future version of GDB creates more than one inferior
166 iterate_over_inferiors (report_initial_inferior
, mi
);
173 mi_interpreter_resume (void *data
)
175 struct mi_interp
*mi
= data
;
177 /* As per hack note in mi_interpreter_init, swap in the output
179 gdb_setup_readline ();
181 /* These overwrite some of the initialization done in
182 _intialize_event_loop. */
183 call_readline
= gdb_readline2
;
184 input_handler
= mi_execute_command_input_handler
;
185 async_command_editing_p
= 0;
186 /* FIXME: This is a total hack for now. PB's use of the MI
187 implicitly relies on a bug in the async support which allows
188 asynchronous commands to leak through the commmand loop. The bug
189 involves (but is not limited to) the fact that sync_execution was
190 erroneously initialized to 0. Duplicate by initializing it thus
194 gdb_stdout
= mi
->out
;
195 /* Route error and log output through the MI. */
196 gdb_stderr
= mi
->err
;
197 gdb_stdlog
= mi
->log
;
198 /* Route target output through the MI. */
199 gdb_stdtarg
= mi
->targ
;
200 /* Route target error through the MI as well. */
201 gdb_stdtargerr
= mi
->targ
;
203 /* Replace all the hooks that we know about. There really needs to
204 be a better way of doing this... */
205 clear_interpreter_hooks ();
207 deprecated_show_load_progress
= mi_load_progress
;
213 mi_interpreter_suspend (void *data
)
215 gdb_disable_readline ();
219 static struct gdb_exception
220 mi_interpreter_exec (void *data
, const char *command
)
222 mi_execute_command_wrapper (command
);
223 return exception_none
;
227 mi_cmd_interpreter_exec (char *command
, char **argv
, int argc
)
229 struct interp
*interp_to_use
;
231 char *mi_error_message
= NULL
;
232 struct cleanup
*old_chain
;
235 error (_("-interpreter-exec: "
236 "Usage: -interpreter-exec interp command"));
238 interp_to_use
= interp_lookup (argv
[0]);
239 if (interp_to_use
== NULL
)
240 error (_("-interpreter-exec: could not find interpreter \"%s\""),
243 /* Note that unlike the CLI version of this command, we don't
244 actually set INTERP_TO_USE as the current interpreter, as we
245 still want gdb_stdout, etc. to point at MI streams. */
247 /* Insert the MI out hooks, making sure to also call the
248 interpreter's hooks if it has any. */
249 /* KRS: We shouldn't need this... Events should be installed and
250 they should just ALWAYS fire something out down the MI
252 mi_insert_notify_hooks ();
254 /* Now run the code. */
256 old_chain
= make_cleanup (null_cleanup
, 0);
257 for (i
= 1; i
< argc
; i
++)
259 struct gdb_exception e
= interp_exec (interp_to_use
, argv
[i
]);
263 mi_error_message
= xstrdup (e
.message
);
264 make_cleanup (xfree
, mi_error_message
);
269 mi_remove_notify_hooks ();
271 if (mi_error_message
!= NULL
)
272 error ("%s", mi_error_message
);
273 do_cleanups (old_chain
);
276 /* This inserts a number of hooks that are meant to produce
277 async-notify ("=") MI messages while running commands in another
278 interpreter using mi_interpreter_exec. The canonical use for this
279 is to allow access to the gdb CLI interpreter from within the MI,
280 while still producing MI style output when actions in the CLI
281 command change GDB's state. */
284 mi_insert_notify_hooks (void)
286 deprecated_query_hook
= mi_interp_query_hook
;
290 mi_remove_notify_hooks (void)
292 deprecated_query_hook
= NULL
;
296 mi_interp_query_hook (const char *ctlstr
, va_list ap
)
302 mi_execute_command_wrapper (const char *cmd
)
304 mi_execute_command (cmd
, stdin
== instream
);
307 /* mi_execute_command_wrapper wrapper suitable for INPUT_HANDLER. */
310 mi_execute_command_input_handler (char *cmd
)
312 mi_execute_command_wrapper (cmd
);
314 fputs_unfiltered ("(gdb) \n", raw_stdout
);
315 gdb_flush (raw_stdout
);
319 mi_command_loop (void *data
)
321 /* Turn off 8 bit strings in quoted output. Any character with the
322 high bit set is printed using C's octal format. */
323 sevenbit_strings
= 1;
325 /* Tell the world that we're alive. */
326 fputs_unfiltered ("(gdb) \n", raw_stdout
);
327 gdb_flush (raw_stdout
);
333 mi_new_thread (struct thread_info
*t
)
335 struct mi_interp
*mi
= top_level_interpreter_data ();
336 struct inferior
*inf
= find_inferior_pid (ptid_get_pid (t
->ptid
));
340 fprintf_unfiltered (mi
->event_channel
,
341 "thread-created,id=\"%d\",group-id=\"i%d\"",
343 gdb_flush (mi
->event_channel
);
347 mi_thread_exit (struct thread_info
*t
, int silent
)
349 struct mi_interp
*mi
;
350 struct inferior
*inf
;
355 inf
= find_inferior_pid (ptid_get_pid (t
->ptid
));
357 mi
= top_level_interpreter_data ();
358 target_terminal_ours ();
359 fprintf_unfiltered (mi
->event_channel
,
360 "thread-exited,id=\"%d\",group-id=\"i%d\"",
362 gdb_flush (mi
->event_channel
);
365 /* Emit notification on changing the state of record. */
368 mi_record_changed (struct inferior
*inferior
, int started
)
370 struct mi_interp
*mi
= top_level_interpreter_data ();
372 fprintf_unfiltered (mi
->event_channel
, "record-%s,thread-group=\"i%d\"",
373 started
? "started" : "stopped", inferior
->num
);
375 gdb_flush (mi
->event_channel
);
379 mi_inferior_added (struct inferior
*inf
)
381 struct mi_interp
*mi
= top_level_interpreter_data ();
383 target_terminal_ours ();
384 fprintf_unfiltered (mi
->event_channel
,
385 "thread-group-added,id=\"i%d\"",
387 gdb_flush (mi
->event_channel
);
391 mi_inferior_appeared (struct inferior
*inf
)
393 struct mi_interp
*mi
= top_level_interpreter_data ();
395 target_terminal_ours ();
396 fprintf_unfiltered (mi
->event_channel
,
397 "thread-group-started,id=\"i%d\",pid=\"%d\"",
399 gdb_flush (mi
->event_channel
);
403 mi_inferior_exit (struct inferior
*inf
)
405 struct mi_interp
*mi
= top_level_interpreter_data ();
407 target_terminal_ours ();
408 if (inf
->has_exit_code
)
409 fprintf_unfiltered (mi
->event_channel
,
410 "thread-group-exited,id=\"i%d\",exit-code=\"%s\"",
411 inf
->num
, int_string (inf
->exit_code
, 8, 0, 0, 1));
413 fprintf_unfiltered (mi
->event_channel
,
414 "thread-group-exited,id=\"i%d\"", inf
->num
);
416 gdb_flush (mi
->event_channel
);
420 mi_inferior_removed (struct inferior
*inf
)
422 struct mi_interp
*mi
= top_level_interpreter_data ();
424 target_terminal_ours ();
425 fprintf_unfiltered (mi
->event_channel
,
426 "thread-group-removed,id=\"i%d\"",
428 gdb_flush (mi
->event_channel
);
431 /* Cleanup that restores a previous current uiout. */
434 restore_current_uiout_cleanup (void *arg
)
436 struct ui_out
*saved_uiout
= arg
;
438 current_uiout
= saved_uiout
;
441 /* Return the MI interpreter, if it is active -- either because it's
442 the top-level interpreter or the interpreter executing the current
443 command. Returns NULL if the MI interpreter is not being used. */
445 static struct interp
*
446 find_mi_interpreter (void)
448 struct interp
*interp
;
450 interp
= top_level_interpreter ();
451 if (ui_out_is_mi_like_p (interp_ui_out (interp
)))
454 interp
= command_interp ();
455 if (ui_out_is_mi_like_p (interp_ui_out (interp
)))
461 /* Return the MI_INTERP structure of the active MI interpreter.
462 Returns NULL if MI is not active. */
464 static struct mi_interp
*
465 mi_interp_data (void)
467 struct interp
*interp
= find_mi_interpreter ();
470 return interp_data (interp
);
474 /* Observers for several run control events that print why the
475 inferior has stopped to both the the MI event channel and to the MI
476 console. If the MI interpreter is not active, print nothing. */
478 /* Observer for the signal_received notification. */
481 mi_on_signal_received (enum gdb_signal siggnal
)
483 struct mi_interp
*mi
= mi_interp_data ();
488 print_signal_received_reason (mi
->mi_uiout
, siggnal
);
489 print_signal_received_reason (mi
->cli_uiout
, siggnal
);
492 /* Observer for the end_stepping_range notification. */
495 mi_on_end_stepping_range (void)
497 struct mi_interp
*mi
= mi_interp_data ();
502 print_end_stepping_range_reason (mi
->mi_uiout
);
503 print_end_stepping_range_reason (mi
->cli_uiout
);
506 /* Observer for the signal_exited notification. */
509 mi_on_signal_exited (enum gdb_signal siggnal
)
511 struct mi_interp
*mi
= mi_interp_data ();
516 print_signal_exited_reason (mi
->mi_uiout
, siggnal
);
517 print_signal_exited_reason (mi
->cli_uiout
, siggnal
);
520 /* Observer for the exited notification. */
523 mi_on_exited (int exitstatus
)
525 struct mi_interp
*mi
= mi_interp_data ();
530 print_exited_reason (mi
->mi_uiout
, exitstatus
);
531 print_exited_reason (mi
->cli_uiout
, exitstatus
);
534 /* Observer for the no_history notification. */
537 mi_on_no_history (void)
539 struct mi_interp
*mi
= mi_interp_data ();
544 print_no_history_reason (mi
->mi_uiout
);
545 print_no_history_reason (mi
->cli_uiout
);
549 mi_on_normal_stop (struct bpstats
*bs
, int print_frame
)
551 /* Since this can be called when CLI command is executing,
552 using cli interpreter, be sure to use MI uiout for output,
553 not the current one. */
554 struct ui_out
*mi_uiout
= interp_ui_out (top_level_interpreter ());
560 if (current_uiout
!= mi_uiout
)
562 /* The normal_stop function has printed frame information
563 into CLI uiout, or some other non-MI uiout. There's no
564 way we can extract proper fields from random uiout
565 object, so we print the frame again. In practice, this
566 can only happen when running a CLI command in MI. */
567 struct ui_out
*saved_uiout
= current_uiout
;
568 struct target_waitstatus last
;
571 current_uiout
= mi_uiout
;
573 get_last_target_status (&last_ptid
, &last
);
574 print_stop_event (&last
);
576 current_uiout
= saved_uiout
;
578 /* Otherwise, frame information has already been printed by
582 /* Breakpoint hits should always be mirrored to the console.
583 Deciding what to mirror to the console wrt to breakpoints
584 and random stops gets messy real fast. E.g., say "s"
585 trips on a breakpoint. We'd clearly want to mirror the
586 event to the console in this case. But what about more
587 complicated cases like "s&; thread n; s&", and one of
588 those steps spawning a new thread, and that thread
589 hitting a breakpoint? It's impossible in general to
590 track whether the thread had any relation to the commands
591 that had been executed. So we just simplify and always
592 mirror breakpoints and random events to the console.
594 Also, CLI execution commands (-interpreter-exec console
595 "next", for example) in async mode have the opposite
596 issue as described in the "then" branch above --
597 normal_stop has already printed frame information to MI
598 uiout, but nothing has printed the same information to
599 the CLI channel. We should print the source line to the
600 console when stepping or other similar commands, iff the
601 step was started by a console command (but not if it was
602 started with -exec-step or similar). */
603 struct thread_info
*tp
= inferior_thread ();
605 if ((!tp
->control
.stop_step
606 && !tp
->control
.proceed_to_finish
)
607 || (tp
->control
.command_interp
!= NULL
608 && tp
->control
.command_interp
!= top_level_interpreter ()))
610 struct mi_interp
*mi
= top_level_interpreter_data ();
611 struct target_waitstatus last
;
613 struct cleanup
*old_chain
;
615 /* Set the current uiout to CLI uiout temporarily. */
616 old_chain
= make_cleanup (restore_current_uiout_cleanup
,
618 current_uiout
= mi
->cli_uiout
;
620 get_last_target_status (&last_ptid
, &last
);
621 print_stop_event (&last
);
623 do_cleanups (old_chain
);
627 ui_out_field_int (mi_uiout
, "thread-id",
628 pid_to_thread_id (inferior_ptid
));
631 struct cleanup
*back_to
= make_cleanup_ui_out_list_begin_end
632 (mi_uiout
, "stopped-threads");
634 ui_out_field_int (mi_uiout
, NULL
,
635 pid_to_thread_id (inferior_ptid
));
636 do_cleanups (back_to
);
639 ui_out_field_string (mi_uiout
, "stopped-threads", "all");
641 core
= target_core_of_thread (inferior_ptid
);
643 ui_out_field_int (mi_uiout
, "core", core
);
646 fputs_unfiltered ("*stopped", raw_stdout
);
647 mi_out_put (mi_uiout
, raw_stdout
);
648 mi_out_rewind (mi_uiout
);
649 mi_print_timing_maybe ();
650 fputs_unfiltered ("\n", raw_stdout
);
651 gdb_flush (raw_stdout
);
655 mi_about_to_proceed (void)
657 /* Suppress output while calling an inferior function. */
659 if (!ptid_equal (inferior_ptid
, null_ptid
))
661 struct thread_info
*tp
= inferior_thread ();
663 if (tp
->control
.in_infcall
)
670 /* When the element is non-zero, no MI notifications will be emitted in
671 response to the corresponding observers. */
673 struct mi_suppress_notification mi_suppress_notification
=
680 /* Emit notification on changing a traceframe. */
683 mi_traceframe_changed (int tfnum
, int tpnum
)
685 struct mi_interp
*mi
= top_level_interpreter_data ();
687 if (mi_suppress_notification
.traceframe
)
690 target_terminal_ours ();
693 fprintf_unfiltered (mi
->event_channel
, "traceframe-changed,"
694 "num=\"%d\",tracepoint=\"%d\"\n",
697 fprintf_unfiltered (mi
->event_channel
, "traceframe-changed,end");
699 gdb_flush (mi
->event_channel
);
702 /* Emit notification on creating a trace state variable. */
705 mi_tsv_created (const struct trace_state_variable
*tsv
)
707 struct mi_interp
*mi
= top_level_interpreter_data ();
709 target_terminal_ours ();
711 fprintf_unfiltered (mi
->event_channel
, "tsv-created,"
712 "name=\"%s\",initial=\"%s\"\n",
713 tsv
->name
, plongest (tsv
->initial_value
));
715 gdb_flush (mi
->event_channel
);
718 /* Emit notification on deleting a trace state variable. */
721 mi_tsv_deleted (const struct trace_state_variable
*tsv
)
723 struct mi_interp
*mi
= top_level_interpreter_data ();
725 target_terminal_ours ();
728 fprintf_unfiltered (mi
->event_channel
, "tsv-deleted,"
729 "name=\"%s\"\n", tsv
->name
);
731 fprintf_unfiltered (mi
->event_channel
, "tsv-deleted\n");
733 gdb_flush (mi
->event_channel
);
736 /* Emit notification on modifying a trace state variable. */
739 mi_tsv_modified (const struct trace_state_variable
*tsv
)
741 struct mi_interp
*mi
= top_level_interpreter_data ();
742 struct ui_out
*mi_uiout
= interp_ui_out (top_level_interpreter ());
744 target_terminal_ours ();
746 fprintf_unfiltered (mi
->event_channel
,
749 ui_out_redirect (mi_uiout
, mi
->event_channel
);
751 ui_out_field_string (mi_uiout
, "name", tsv
->name
);
752 ui_out_field_string (mi_uiout
, "initial",
753 plongest (tsv
->initial_value
));
754 if (tsv
->value_known
)
755 ui_out_field_string (mi_uiout
, "current", plongest (tsv
->value
));
757 ui_out_redirect (mi_uiout
, NULL
);
759 gdb_flush (mi
->event_channel
);
762 /* Emit notification about a created breakpoint. */
765 mi_breakpoint_created (struct breakpoint
*b
)
767 struct mi_interp
*mi
= top_level_interpreter_data ();
768 struct ui_out
*mi_uiout
= interp_ui_out (top_level_interpreter ());
769 volatile struct gdb_exception e
;
771 if (mi_suppress_notification
.breakpoint
)
777 target_terminal_ours ();
778 fprintf_unfiltered (mi
->event_channel
,
779 "breakpoint-created");
780 /* We want the output from gdb_breakpoint_query to go to
781 mi->event_channel. One approach would be to just call
782 gdb_breakpoint_query, and then use mi_out_put to send the current
783 content of mi_outout into mi->event_channel. However, that will
784 break if anything is output to mi_uiout prior to calling the
785 breakpoint_created notifications. So, we use
787 ui_out_redirect (mi_uiout
, mi
->event_channel
);
788 TRY_CATCH (e
, RETURN_MASK_ERROR
)
789 gdb_breakpoint_query (mi_uiout
, b
->number
, NULL
);
790 ui_out_redirect (mi_uiout
, NULL
);
792 gdb_flush (mi
->event_channel
);
795 /* Emit notification about deleted breakpoint. */
798 mi_breakpoint_deleted (struct breakpoint
*b
)
800 struct mi_interp
*mi
= top_level_interpreter_data ();
802 if (mi_suppress_notification
.breakpoint
)
808 target_terminal_ours ();
810 fprintf_unfiltered (mi
->event_channel
, "breakpoint-deleted,id=\"%d\"",
813 gdb_flush (mi
->event_channel
);
816 /* Emit notification about modified breakpoint. */
819 mi_breakpoint_modified (struct breakpoint
*b
)
821 struct mi_interp
*mi
= top_level_interpreter_data ();
822 struct ui_out
*mi_uiout
= interp_ui_out (top_level_interpreter ());
823 volatile struct gdb_exception e
;
825 if (mi_suppress_notification
.breakpoint
)
831 target_terminal_ours ();
832 fprintf_unfiltered (mi
->event_channel
,
833 "breakpoint-modified");
834 /* We want the output from gdb_breakpoint_query to go to
835 mi->event_channel. One approach would be to just call
836 gdb_breakpoint_query, and then use mi_out_put to send the current
837 content of mi_outout 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 (mi_uiout
, mi
->event_channel
);
842 TRY_CATCH (e
, RETURN_MASK_ERROR
)
843 gdb_breakpoint_query (mi_uiout
, b
->number
, NULL
);
844 ui_out_redirect (mi_uiout
, NULL
);
846 gdb_flush (mi
->event_channel
);
850 mi_output_running_pid (struct thread_info
*info
, void *arg
)
854 if (ptid_get_pid (*ptid
) == ptid_get_pid (info
->ptid
))
855 fprintf_unfiltered (raw_stdout
,
856 "*running,thread-id=\"%d\"\n",
863 mi_inferior_count (struct inferior
*inf
, void *arg
)
875 mi_on_resume (ptid_t ptid
)
877 struct thread_info
*tp
= NULL
;
879 if (ptid_equal (ptid
, minus_one_ptid
) || ptid_is_pid (ptid
))
880 tp
= inferior_thread ();
882 tp
= find_thread_ptid (ptid
);
884 /* Suppress output while calling an inferior function. */
885 if (tp
->control
.in_infcall
)
888 /* To cater for older frontends, emit ^running, but do it only once
889 per each command. We do it here, since at this point we know
890 that the target was successfully resumed, and in non-async mode,
891 we won't return back to MI interpreter code until the target
892 is done running, so delaying the output of "^running" until then
893 will make it impossible for frontend to know what's going on.
895 In future (MI3), we'll be outputting "^done" here. */
896 if (!running_result_record_printed
&& mi_proceeded
)
898 fprintf_unfiltered (raw_stdout
, "%s^running\n",
899 current_token
? current_token
: "");
902 if (ptid_get_pid (ptid
) == -1)
903 fprintf_unfiltered (raw_stdout
, "*running,thread-id=\"all\"\n");
904 else if (ptid_is_pid (ptid
))
908 /* Backwards compatibility. If there's only one inferior,
909 output "all", otherwise, output each resumed thread
911 iterate_over_inferiors (mi_inferior_count
, &count
);
914 fprintf_unfiltered (raw_stdout
, "*running,thread-id=\"all\"\n");
916 iterate_over_threads (mi_output_running_pid
, &ptid
);
920 struct thread_info
*ti
= find_thread_ptid (ptid
);
923 fprintf_unfiltered (raw_stdout
, "*running,thread-id=\"%d\"\n", ti
->num
);
926 if (!running_result_record_printed
&& mi_proceeded
)
928 running_result_record_printed
= 1;
929 /* This is what gdb used to do historically -- printing prompt even if
930 it cannot actually accept any input. This will be surely removed
931 for MI3, and may be removed even earler. */
932 /* FIXME: review the use of target_is_async_p here -- is that
934 if (!target_is_async_p ())
935 fputs_unfiltered ("(gdb) \n", raw_stdout
);
937 gdb_flush (raw_stdout
);
941 mi_solib_loaded (struct so_list
*solib
)
943 struct mi_interp
*mi
= top_level_interpreter_data ();
945 target_terminal_ours ();
946 if (gdbarch_has_global_solist (target_gdbarch ()))
947 fprintf_unfiltered (mi
->event_channel
,
948 "library-loaded,id=\"%s\",target-name=\"%s\","
949 "host-name=\"%s\",symbols-loaded=\"%d\"",
950 solib
->so_original_name
, solib
->so_original_name
,
951 solib
->so_name
, solib
->symbols_loaded
);
953 fprintf_unfiltered (mi
->event_channel
,
954 "library-loaded,id=\"%s\",target-name=\"%s\","
955 "host-name=\"%s\",symbols-loaded=\"%d\","
956 "thread-group=\"i%d\"",
957 solib
->so_original_name
, solib
->so_original_name
,
958 solib
->so_name
, solib
->symbols_loaded
,
959 current_inferior ()->num
);
961 gdb_flush (mi
->event_channel
);
965 mi_solib_unloaded (struct so_list
*solib
)
967 struct mi_interp
*mi
= top_level_interpreter_data ();
969 target_terminal_ours ();
970 if (gdbarch_has_global_solist (target_gdbarch ()))
971 fprintf_unfiltered (mi
->event_channel
,
972 "library-unloaded,id=\"%s\",target-name=\"%s\","
974 solib
->so_original_name
, solib
->so_original_name
,
977 fprintf_unfiltered (mi
->event_channel
,
978 "library-unloaded,id=\"%s\",target-name=\"%s\","
979 "host-name=\"%s\",thread-group=\"i%d\"",
980 solib
->so_original_name
, solib
->so_original_name
,
981 solib
->so_name
, current_inferior ()->num
);
983 gdb_flush (mi
->event_channel
);
986 /* Emit notification about the command parameter change. */
989 mi_command_param_changed (const char *param
, const char *value
)
991 struct mi_interp
*mi
= top_level_interpreter_data ();
992 struct ui_out
*mi_uiout
= interp_ui_out (top_level_interpreter ());
994 if (mi_suppress_notification
.cmd_param_changed
)
997 target_terminal_ours ();
999 fprintf_unfiltered (mi
->event_channel
,
1000 "cmd-param-changed");
1002 ui_out_redirect (mi_uiout
, mi
->event_channel
);
1004 ui_out_field_string (mi_uiout
, "param", param
);
1005 ui_out_field_string (mi_uiout
, "value", value
);
1007 ui_out_redirect (mi_uiout
, NULL
);
1009 gdb_flush (mi
->event_channel
);
1012 /* Emit notification about the target memory change. */
1015 mi_memory_changed (struct inferior
*inferior
, CORE_ADDR memaddr
,
1016 ssize_t len
, const bfd_byte
*myaddr
)
1018 struct mi_interp
*mi
= top_level_interpreter_data ();
1019 struct ui_out
*mi_uiout
= interp_ui_out (top_level_interpreter ());
1020 struct obj_section
*sec
;
1022 if (mi_suppress_notification
.memory
)
1025 target_terminal_ours ();
1027 fprintf_unfiltered (mi
->event_channel
,
1030 ui_out_redirect (mi_uiout
, mi
->event_channel
);
1032 ui_out_field_fmt (mi_uiout
, "thread-group", "i%d", inferior
->num
);
1033 ui_out_field_core_addr (mi_uiout
, "addr", target_gdbarch (), memaddr
);
1034 ui_out_field_fmt (mi_uiout
, "len", "%s", hex_string (len
));
1036 /* Append 'type=code' into notification if MEMADDR falls in the range of
1037 sections contain code. */
1038 sec
= find_pc_section (memaddr
);
1039 if (sec
!= NULL
&& sec
->objfile
!= NULL
)
1041 flagword flags
= bfd_get_section_flags (sec
->objfile
->obfd
,
1042 sec
->the_bfd_section
);
1044 if (flags
& SEC_CODE
)
1045 ui_out_field_string (mi_uiout
, "type", "code");
1048 ui_out_redirect (mi_uiout
, NULL
);
1050 gdb_flush (mi
->event_channel
);
1054 report_initial_inferior (struct inferior
*inf
, void *closure
)
1056 /* This function is called from mi_intepreter_init, and since
1057 mi_inferior_added assumes that inferior is fully initialized
1058 and top_level_interpreter_data is set, we cannot call
1060 struct mi_interp
*mi
= closure
;
1062 target_terminal_ours ();
1063 fprintf_unfiltered (mi
->event_channel
,
1064 "thread-group-added,id=\"i%d\"",
1066 gdb_flush (mi
->event_channel
);
1070 static struct ui_out
*
1071 mi_ui_out (struct interp
*interp
)
1073 struct mi_interp
*mi
= interp_data (interp
);
1075 return mi
->mi_uiout
;
1078 /* Save the original value of raw_stdout here when logging, so we can
1079 restore correctly when done. */
1081 static struct ui_file
*saved_raw_stdout
;
1083 /* Do MI-specific logging actions; save raw_stdout, and change all
1084 the consoles to use the supplied ui-file(s). */
1087 mi_set_logging (struct interp
*interp
, int start_log
,
1088 struct ui_file
*out
, struct ui_file
*logfile
)
1090 struct mi_interp
*mi
= interp_data (interp
);
1097 /* The tee created already is based on gdb_stdout, which for MI
1098 is a console and so we end up in an infinite loop of console
1099 writing to ui_file writing to console etc. So discard the
1100 existing tee (it hasn't been used yet, and MI won't ever use
1101 it), and create one based on raw_stdout instead. */
1104 ui_file_delete (out
);
1105 out
= tee_file_new (raw_stdout
, 0, logfile
, 0);
1108 saved_raw_stdout
= raw_stdout
;
1113 raw_stdout
= saved_raw_stdout
;
1114 saved_raw_stdout
= NULL
;
1117 mi_console_set_raw (mi
->out
, raw_stdout
);
1118 mi_console_set_raw (mi
->err
, raw_stdout
);
1119 mi_console_set_raw (mi
->log
, raw_stdout
);
1120 mi_console_set_raw (mi
->targ
, raw_stdout
);
1121 mi_console_set_raw (mi
->event_channel
, raw_stdout
);
1126 extern initialize_file_ftype _initialize_mi_interp
; /* -Wmissing-prototypes */
1129 _initialize_mi_interp (void)
1131 static const struct interp_procs procs
=
1133 mi_interpreter_init
, /* init_proc */
1134 mi_interpreter_resume
, /* resume_proc */
1135 mi_interpreter_suspend
, /* suspend_proc */
1136 mi_interpreter_exec
, /* exec_proc */
1137 mi_ui_out
, /* ui_out_proc */
1138 mi_set_logging
, /* set_logging_proc */
1139 mi_command_loop
/* command_loop_proc */
1142 /* The various interpreter levels. */
1143 interp_add (interp_new (INTERP_MI1
, &procs
));
1144 interp_add (interp_new (INTERP_MI2
, &procs
));
1145 interp_add (interp_new (INTERP_MI3
, &procs
));
1146 interp_add (interp_new (INTERP_MI
, &procs
));