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
;
179 /* As per hack note in mi_interpreter_init, swap in the output
181 gdb_setup_readline ();
183 /* These overwrite some of the initialization done in
184 _intialize_event_loop. */
185 call_readline
= gdb_readline_no_editing_callback
;
186 input_handler
= mi_execute_command_input_handler
;
187 async_command_editing_p
= 0;
188 /* FIXME: This is a total hack for now. PB's use of the MI
189 implicitly relies on a bug in the async support which allows
190 asynchronous commands to leak through the commmand loop. The bug
191 involves (but is not limited to) the fact that sync_execution was
192 erroneously initialized to 0. Duplicate by initializing it thus
196 gdb_stdout
= mi
->out
;
197 /* Route error and log output through the MI. */
198 gdb_stderr
= mi
->err
;
199 gdb_stdlog
= mi
->log
;
200 /* Route target output through the MI. */
201 gdb_stdtarg
= mi
->targ
;
202 /* Route target error through the MI as well. */
203 gdb_stdtargerr
= mi
->targ
;
205 /* Replace all the hooks that we know about. There really needs to
206 be a better way of doing this... */
207 clear_interpreter_hooks ();
209 deprecated_show_load_progress
= mi_load_progress
;
215 mi_interpreter_suspend (void *data
)
217 gdb_disable_readline ();
221 static struct gdb_exception
222 mi_interpreter_exec (void *data
, const char *command
)
224 mi_execute_command_wrapper (command
);
225 return exception_none
;
229 mi_cmd_interpreter_exec (char *command
, char **argv
, int argc
)
231 struct interp
*interp_to_use
;
233 char *mi_error_message
= NULL
;
234 struct cleanup
*old_chain
;
237 error (_("-interpreter-exec: "
238 "Usage: -interpreter-exec interp command"));
240 interp_to_use
= interp_lookup (argv
[0]);
241 if (interp_to_use
== NULL
)
242 error (_("-interpreter-exec: could not find interpreter \"%s\""),
245 /* Note that unlike the CLI version of this command, we don't
246 actually set INTERP_TO_USE as the current interpreter, as we
247 still want gdb_stdout, etc. to point at MI streams. */
249 /* Insert the MI out hooks, making sure to also call the
250 interpreter's hooks if it has any. */
251 /* KRS: We shouldn't need this... Events should be installed and
252 they should just ALWAYS fire something out down the MI
254 mi_insert_notify_hooks ();
256 /* Now run the code. */
258 old_chain
= make_cleanup (null_cleanup
, 0);
259 for (i
= 1; i
< argc
; i
++)
261 struct gdb_exception e
= interp_exec (interp_to_use
, argv
[i
]);
265 mi_error_message
= xstrdup (e
.message
);
266 make_cleanup (xfree
, mi_error_message
);
271 mi_remove_notify_hooks ();
273 if (mi_error_message
!= NULL
)
274 error ("%s", mi_error_message
);
275 do_cleanups (old_chain
);
278 /* This inserts a number of hooks that are meant to produce
279 async-notify ("=") MI messages while running commands in another
280 interpreter using mi_interpreter_exec. The canonical use for this
281 is to allow access to the gdb CLI interpreter from within the MI,
282 while still producing MI style output when actions in the CLI
283 command change GDB's state. */
286 mi_insert_notify_hooks (void)
288 deprecated_query_hook
= mi_interp_query_hook
;
292 mi_remove_notify_hooks (void)
294 deprecated_query_hook
= NULL
;
298 mi_interp_query_hook (const char *ctlstr
, va_list ap
)
304 mi_execute_command_wrapper (const char *cmd
)
306 mi_execute_command (cmd
, stdin
== instream
);
309 /* Observer for the synchronous_command_done notification. */
312 mi_on_sync_execution_done (void)
314 /* If MI is sync, then output the MI prompt now, indicating we're
315 ready for further input. */
318 fputs_unfiltered ("(gdb) \n", raw_stdout
);
319 gdb_flush (raw_stdout
);
323 /* mi_execute_command_wrapper wrapper suitable for INPUT_HANDLER. */
326 mi_execute_command_input_handler (char *cmd
)
328 mi_execute_command_wrapper (cmd
);
330 /* Print a prompt, indicating we're ready for further input, unless
331 we just started a synchronous command. In that case, we're about
332 to go back to the event loop and will output the prompt in the
333 'synchronous_command_done' observer when the target next
337 fputs_unfiltered ("(gdb) \n", raw_stdout
);
338 gdb_flush (raw_stdout
);
343 mi_command_loop (void *data
)
345 /* Turn off 8 bit strings in quoted output. Any character with the
346 high bit set is printed using C's octal format. */
347 sevenbit_strings
= 1;
349 /* Tell the world that we're alive. */
350 fputs_unfiltered ("(gdb) \n", raw_stdout
);
351 gdb_flush (raw_stdout
);
357 mi_new_thread (struct thread_info
*t
)
359 struct mi_interp
*mi
= (struct mi_interp
*) top_level_interpreter_data ();
360 struct inferior
*inf
= find_inferior_ptid (t
->ptid
);
361 struct cleanup
*old_chain
;
365 old_chain
= make_cleanup_restore_target_terminal ();
366 target_terminal_ours_for_output ();
368 fprintf_unfiltered (mi
->event_channel
,
369 "thread-created,id=\"%d\",group-id=\"i%d\"",
370 t
->global_num
, inf
->num
);
371 gdb_flush (mi
->event_channel
);
373 do_cleanups (old_chain
);
377 mi_thread_exit (struct thread_info
*t
, int silent
)
379 struct mi_interp
*mi
;
380 struct inferior
*inf
;
381 struct cleanup
*old_chain
;
386 inf
= find_inferior_ptid (t
->ptid
);
388 mi
= (struct mi_interp
*) top_level_interpreter_data ();
389 old_chain
= make_cleanup_restore_target_terminal ();
390 target_terminal_ours_for_output ();
392 fprintf_unfiltered (mi
->event_channel
,
393 "thread-exited,id=\"%d\",group-id=\"i%d\"",
394 t
->global_num
, inf
->num
);
395 gdb_flush (mi
->event_channel
);
397 do_cleanups (old_chain
);
400 /* Emit notification on changing the state of record. */
403 mi_record_changed (struct inferior
*inferior
, int started
, const char *method
,
406 struct mi_interp
*mi
= (struct mi_interp
*) top_level_interpreter_data ();
407 struct cleanup
*old_chain
;
409 old_chain
= make_cleanup_restore_target_terminal ();
410 target_terminal_ours_for_output ();
418 "record-started,thread-group=\"i%d\",method=\"%s\",format=\"%s\"",
419 inferior
->num
, method
, format
);
425 "record-started,thread-group=\"i%d\",method=\"%s\"",
426 inferior
->num
, method
);
431 fprintf_unfiltered (mi
->event_channel
,
432 "record-stopped,thread-group=\"i%d\"", inferior
->num
);
436 gdb_flush (mi
->event_channel
);
438 do_cleanups (old_chain
);
442 mi_inferior_added (struct inferior
*inf
)
444 struct mi_interp
*mi
= (struct mi_interp
*) top_level_interpreter_data ();
445 struct cleanup
*old_chain
;
447 old_chain
= make_cleanup_restore_target_terminal ();
448 target_terminal_ours_for_output ();
450 fprintf_unfiltered (mi
->event_channel
,
451 "thread-group-added,id=\"i%d\"",
453 gdb_flush (mi
->event_channel
);
455 do_cleanups (old_chain
);
459 mi_inferior_appeared (struct inferior
*inf
)
461 struct mi_interp
*mi
= (struct mi_interp
*) top_level_interpreter_data ();
462 struct cleanup
*old_chain
;
464 old_chain
= make_cleanup_restore_target_terminal ();
465 target_terminal_ours_for_output ();
467 fprintf_unfiltered (mi
->event_channel
,
468 "thread-group-started,id=\"i%d\",pid=\"%d\"",
470 gdb_flush (mi
->event_channel
);
472 do_cleanups (old_chain
);
476 mi_inferior_exit (struct inferior
*inf
)
478 struct mi_interp
*mi
= (struct mi_interp
*) top_level_interpreter_data ();
479 struct cleanup
*old_chain
;
481 old_chain
= make_cleanup_restore_target_terminal ();
482 target_terminal_ours_for_output ();
484 if (inf
->has_exit_code
)
485 fprintf_unfiltered (mi
->event_channel
,
486 "thread-group-exited,id=\"i%d\",exit-code=\"%s\"",
487 inf
->num
, int_string (inf
->exit_code
, 8, 0, 0, 1));
489 fprintf_unfiltered (mi
->event_channel
,
490 "thread-group-exited,id=\"i%d\"", inf
->num
);
491 gdb_flush (mi
->event_channel
);
493 do_cleanups (old_chain
);
497 mi_inferior_removed (struct inferior
*inf
)
499 struct mi_interp
*mi
= (struct mi_interp
*) top_level_interpreter_data ();
500 struct cleanup
*old_chain
;
502 old_chain
= make_cleanup_restore_target_terminal ();
503 target_terminal_ours_for_output ();
505 fprintf_unfiltered (mi
->event_channel
,
506 "thread-group-removed,id=\"i%d\"",
508 gdb_flush (mi
->event_channel
);
510 do_cleanups (old_chain
);
513 /* Return the MI interpreter, if it is active -- either because it's
514 the top-level interpreter or the interpreter executing the current
515 command. Returns NULL if the MI interpreter is not being used. */
517 static struct interp
*
518 find_mi_interpreter (void)
520 struct interp
*interp
;
522 interp
= top_level_interpreter ();
523 if (ui_out_is_mi_like_p (interp_ui_out (interp
)))
526 interp
= command_interp ();
527 if (ui_out_is_mi_like_p (interp_ui_out (interp
)))
533 /* Return the MI_INTERP structure of the active MI interpreter.
534 Returns NULL if MI is not active. */
536 static struct mi_interp
*
537 mi_interp_data (void)
539 struct interp
*interp
= find_mi_interpreter ();
542 return (struct mi_interp
*) interp_data (interp
);
546 /* Observers for several run control events that print why the
547 inferior has stopped to both the the MI event channel and to the MI
548 console. If the MI interpreter is not active, print nothing. */
550 /* Observer for the signal_received notification. */
553 mi_on_signal_received (enum gdb_signal siggnal
)
555 struct mi_interp
*mi
= mi_interp_data ();
560 print_signal_received_reason (mi
->mi_uiout
, siggnal
);
561 print_signal_received_reason (mi
->cli_uiout
, siggnal
);
564 /* Observer for the end_stepping_range notification. */
567 mi_on_end_stepping_range (void)
569 struct mi_interp
*mi
= mi_interp_data ();
574 print_end_stepping_range_reason (mi
->mi_uiout
);
575 print_end_stepping_range_reason (mi
->cli_uiout
);
578 /* Observer for the signal_exited notification. */
581 mi_on_signal_exited (enum gdb_signal siggnal
)
583 struct mi_interp
*mi
= mi_interp_data ();
588 print_signal_exited_reason (mi
->mi_uiout
, siggnal
);
589 print_signal_exited_reason (mi
->cli_uiout
, siggnal
);
592 /* Observer for the exited notification. */
595 mi_on_exited (int exitstatus
)
597 struct mi_interp
*mi
= mi_interp_data ();
602 print_exited_reason (mi
->mi_uiout
, exitstatus
);
603 print_exited_reason (mi
->cli_uiout
, exitstatus
);
606 /* Observer for the no_history notification. */
609 mi_on_no_history (void)
611 struct mi_interp
*mi
= mi_interp_data ();
616 print_no_history_reason (mi
->mi_uiout
);
617 print_no_history_reason (mi
->cli_uiout
);
621 mi_on_normal_stop (struct bpstats
*bs
, int print_frame
)
623 /* Since this can be called when CLI command is executing,
624 using cli interpreter, be sure to use MI uiout for output,
625 not the current one. */
626 struct ui_out
*mi_uiout
= interp_ui_out (top_level_interpreter ());
630 struct thread_info
*tp
;
633 tp
= inferior_thread ();
635 if (tp
->thread_fsm
!= NULL
636 && thread_fsm_finished_p (tp
->thread_fsm
))
638 enum async_reply_reason reason
;
640 reason
= thread_fsm_async_reply_reason (tp
->thread_fsm
);
641 ui_out_field_string (mi_uiout
, "reason",
642 async_reason_lookup (reason
));
644 print_stop_event (mi_uiout
);
646 /* Breakpoint hits should always be mirrored to the console.
647 Deciding what to mirror to the console wrt to breakpoints and
648 random stops gets messy real fast. E.g., say "s" trips on a
649 breakpoint. We'd clearly want to mirror the event to the
650 console in this case. But what about more complicated cases
651 like "s&; thread n; s&", and one of those steps spawning a
652 new thread, and that thread hitting a breakpoint? It's
653 impossible in general to track whether the thread had any
654 relation to the commands that had been executed. So we just
655 simplify and always mirror breakpoints and random events to
658 OTOH, we should print the source line to the console when
659 stepping or other similar commands, iff the step was started
660 by a console command, but not if it was started with
661 -exec-step or similar. */
662 if ((bpstat_what (tp
->control
.stop_bpstat
).main_action
663 == BPSTAT_WHAT_STOP_NOISY
)
664 || !(tp
->thread_fsm
!= NULL
665 && thread_fsm_finished_p (tp
->thread_fsm
))
666 || (tp
->control
.command_interp
!= NULL
667 && tp
->control
.command_interp
!= top_level_interpreter ()))
670 = (struct mi_interp
*) top_level_interpreter_data ();
672 print_stop_event (mi
->cli_uiout
);
675 tp
= inferior_thread ();
676 ui_out_field_int (mi_uiout
, "thread-id", tp
->global_num
);
679 struct cleanup
*back_to
= make_cleanup_ui_out_list_begin_end
680 (mi_uiout
, "stopped-threads");
682 ui_out_field_int (mi_uiout
, NULL
, tp
->global_num
);
683 do_cleanups (back_to
);
686 ui_out_field_string (mi_uiout
, "stopped-threads", "all");
688 core
= target_core_of_thread (inferior_ptid
);
690 ui_out_field_int (mi_uiout
, "core", core
);
693 fputs_unfiltered ("*stopped", raw_stdout
);
694 mi_out_put (mi_uiout
, raw_stdout
);
695 mi_out_rewind (mi_uiout
);
696 mi_print_timing_maybe ();
697 fputs_unfiltered ("\n", raw_stdout
);
698 gdb_flush (raw_stdout
);
702 mi_about_to_proceed (void)
704 /* Suppress output while calling an inferior function. */
706 if (!ptid_equal (inferior_ptid
, null_ptid
))
708 struct thread_info
*tp
= inferior_thread ();
710 if (tp
->control
.in_infcall
)
717 /* When the element is non-zero, no MI notifications will be emitted in
718 response to the corresponding observers. */
720 struct mi_suppress_notification mi_suppress_notification
=
727 /* Emit notification on changing a traceframe. */
730 mi_traceframe_changed (int tfnum
, int tpnum
)
732 struct mi_interp
*mi
= (struct mi_interp
*) top_level_interpreter_data ();
733 struct cleanup
*old_chain
;
735 if (mi_suppress_notification
.traceframe
)
738 old_chain
= make_cleanup_restore_target_terminal ();
739 target_terminal_ours_for_output ();
742 fprintf_unfiltered (mi
->event_channel
, "traceframe-changed,"
743 "num=\"%d\",tracepoint=\"%d\"\n",
746 fprintf_unfiltered (mi
->event_channel
, "traceframe-changed,end");
748 gdb_flush (mi
->event_channel
);
750 do_cleanups (old_chain
);
753 /* Emit notification on creating a trace state variable. */
756 mi_tsv_created (const struct trace_state_variable
*tsv
)
758 struct mi_interp
*mi
= (struct mi_interp
*) top_level_interpreter_data ();
759 struct cleanup
*old_chain
;
761 old_chain
= make_cleanup_restore_target_terminal ();
762 target_terminal_ours_for_output ();
764 fprintf_unfiltered (mi
->event_channel
, "tsv-created,"
765 "name=\"%s\",initial=\"%s\"\n",
766 tsv
->name
, plongest (tsv
->initial_value
));
768 gdb_flush (mi
->event_channel
);
770 do_cleanups (old_chain
);
773 /* Emit notification on deleting a trace state variable. */
776 mi_tsv_deleted (const struct trace_state_variable
*tsv
)
778 struct mi_interp
*mi
= (struct mi_interp
*) top_level_interpreter_data ();
779 struct cleanup
*old_chain
;
781 old_chain
= make_cleanup_restore_target_terminal ();
782 target_terminal_ours_for_output ();
785 fprintf_unfiltered (mi
->event_channel
, "tsv-deleted,"
786 "name=\"%s\"\n", tsv
->name
);
788 fprintf_unfiltered (mi
->event_channel
, "tsv-deleted\n");
790 gdb_flush (mi
->event_channel
);
792 do_cleanups (old_chain
);
795 /* Emit notification on modifying a trace state variable. */
798 mi_tsv_modified (const struct trace_state_variable
*tsv
)
800 struct mi_interp
*mi
= (struct mi_interp
*) top_level_interpreter_data ();
801 struct ui_out
*mi_uiout
= interp_ui_out (top_level_interpreter ());
802 struct cleanup
*old_chain
;
804 old_chain
= make_cleanup_restore_target_terminal ();
805 target_terminal_ours_for_output ();
807 fprintf_unfiltered (mi
->event_channel
,
810 ui_out_redirect (mi_uiout
, mi
->event_channel
);
812 ui_out_field_string (mi_uiout
, "name", tsv
->name
);
813 ui_out_field_string (mi_uiout
, "initial",
814 plongest (tsv
->initial_value
));
815 if (tsv
->value_known
)
816 ui_out_field_string (mi_uiout
, "current", plongest (tsv
->value
));
818 ui_out_redirect (mi_uiout
, NULL
);
820 gdb_flush (mi
->event_channel
);
822 do_cleanups (old_chain
);
825 /* Emit notification about a created breakpoint. */
828 mi_breakpoint_created (struct breakpoint
*b
)
830 struct mi_interp
*mi
= (struct mi_interp
*) top_level_interpreter_data ();
831 struct ui_out
*mi_uiout
= interp_ui_out (top_level_interpreter ());
832 struct cleanup
*old_chain
;
834 if (mi_suppress_notification
.breakpoint
)
840 old_chain
= make_cleanup_restore_target_terminal ();
841 target_terminal_ours_for_output ();
843 fprintf_unfiltered (mi
->event_channel
,
844 "breakpoint-created");
845 /* We want the output from gdb_breakpoint_query to go to
846 mi->event_channel. One approach would be to just call
847 gdb_breakpoint_query, and then use mi_out_put to send the current
848 content of mi_outout into mi->event_channel. However, that will
849 break if anything is output to mi_uiout prior to calling the
850 breakpoint_created notifications. So, we use
852 ui_out_redirect (mi_uiout
, mi
->event_channel
);
855 gdb_breakpoint_query (mi_uiout
, b
->number
, NULL
);
857 CATCH (e
, RETURN_MASK_ERROR
)
862 ui_out_redirect (mi_uiout
, NULL
);
864 gdb_flush (mi
->event_channel
);
866 do_cleanups (old_chain
);
869 /* Emit notification about deleted breakpoint. */
872 mi_breakpoint_deleted (struct breakpoint
*b
)
874 struct mi_interp
*mi
= (struct mi_interp
*) top_level_interpreter_data ();
875 struct cleanup
*old_chain
;
877 if (mi_suppress_notification
.breakpoint
)
883 old_chain
= make_cleanup_restore_target_terminal ();
884 target_terminal_ours_for_output ();
886 fprintf_unfiltered (mi
->event_channel
, "breakpoint-deleted,id=\"%d\"",
889 gdb_flush (mi
->event_channel
);
891 do_cleanups (old_chain
);
894 /* Emit notification about modified breakpoint. */
897 mi_breakpoint_modified (struct breakpoint
*b
)
899 struct mi_interp
*mi
= (struct mi_interp
*) top_level_interpreter_data ();
900 struct ui_out
*mi_uiout
= interp_ui_out (top_level_interpreter ());
901 struct cleanup
*old_chain
;
903 if (mi_suppress_notification
.breakpoint
)
909 old_chain
= make_cleanup_restore_target_terminal ();
910 target_terminal_ours_for_output ();
912 fprintf_unfiltered (mi
->event_channel
,
913 "breakpoint-modified");
914 /* We want the output from gdb_breakpoint_query to go to
915 mi->event_channel. One approach would be to just call
916 gdb_breakpoint_query, and then use mi_out_put to send the current
917 content of mi_outout into mi->event_channel. However, that will
918 break if anything is output to mi_uiout prior to calling the
919 breakpoint_created notifications. So, we use
921 ui_out_redirect (mi_uiout
, mi
->event_channel
);
924 gdb_breakpoint_query (mi_uiout
, b
->number
, NULL
);
926 CATCH (e
, RETURN_MASK_ERROR
)
931 ui_out_redirect (mi_uiout
, NULL
);
933 gdb_flush (mi
->event_channel
);
935 do_cleanups (old_chain
);
939 mi_output_running_pid (struct thread_info
*info
, void *arg
)
941 ptid_t
*ptid
= (ptid_t
*) arg
;
943 if (ptid_get_pid (*ptid
) == ptid_get_pid (info
->ptid
))
944 fprintf_unfiltered (raw_stdout
,
945 "*running,thread-id=\"%d\"\n",
952 mi_inferior_count (struct inferior
*inf
, void *arg
)
956 int *count_p
= (int *) arg
;
964 mi_on_resume (ptid_t ptid
)
966 struct thread_info
*tp
= NULL
;
968 if (ptid_equal (ptid
, minus_one_ptid
) || ptid_is_pid (ptid
))
969 tp
= inferior_thread ();
971 tp
= find_thread_ptid (ptid
);
973 /* Suppress output while calling an inferior function. */
974 if (tp
->control
.in_infcall
)
977 /* To cater for older frontends, emit ^running, but do it only once
978 per each command. We do it here, since at this point we know
979 that the target was successfully resumed, and in non-async mode,
980 we won't return back to MI interpreter code until the target
981 is done running, so delaying the output of "^running" until then
982 will make it impossible for frontend to know what's going on.
984 In future (MI3), we'll be outputting "^done" here. */
985 if (!running_result_record_printed
&& mi_proceeded
)
987 fprintf_unfiltered (raw_stdout
, "%s^running\n",
988 current_token
? current_token
: "");
991 if (ptid_get_pid (ptid
) == -1)
992 fprintf_unfiltered (raw_stdout
, "*running,thread-id=\"all\"\n");
993 else if (ptid_is_pid (ptid
))
997 /* Backwards compatibility. If there's only one inferior,
998 output "all", otherwise, output each resumed thread
1000 iterate_over_inferiors (mi_inferior_count
, &count
);
1003 fprintf_unfiltered (raw_stdout
, "*running,thread-id=\"all\"\n");
1005 iterate_over_threads (mi_output_running_pid
, &ptid
);
1009 struct thread_info
*ti
= find_thread_ptid (ptid
);
1012 fprintf_unfiltered (raw_stdout
, "*running,thread-id=\"%d\"\n",
1016 if (!running_result_record_printed
&& mi_proceeded
)
1018 running_result_record_printed
= 1;
1019 /* This is what gdb used to do historically -- printing prompt even if
1020 it cannot actually accept any input. This will be surely removed
1021 for MI3, and may be removed even earlier. SYNC_EXECUTION is
1022 checked here because we only need to emit a prompt if a
1023 synchronous command was issued when the target is async. */
1024 if (!target_can_async_p () || sync_execution
)
1025 fputs_unfiltered ("(gdb) \n", raw_stdout
);
1027 gdb_flush (raw_stdout
);
1031 mi_solib_loaded (struct so_list
*solib
)
1033 struct mi_interp
*mi
= (struct mi_interp
*) top_level_interpreter_data ();
1034 struct ui_out
*uiout
= interp_ui_out (top_level_interpreter ());
1035 struct cleanup
*old_chain
;
1037 old_chain
= make_cleanup_restore_target_terminal ();
1038 target_terminal_ours_for_output ();
1040 fprintf_unfiltered (mi
->event_channel
, "library-loaded");
1042 ui_out_redirect (uiout
, mi
->event_channel
);
1044 ui_out_field_string (uiout
, "id", solib
->so_original_name
);
1045 ui_out_field_string (uiout
, "target-name", solib
->so_original_name
);
1046 ui_out_field_string (uiout
, "host-name", solib
->so_name
);
1047 ui_out_field_int (uiout
, "symbols-loaded", solib
->symbols_loaded
);
1048 if (!gdbarch_has_global_solist (target_gdbarch ()))
1050 ui_out_field_fmt (uiout
, "thread-group", "i%d",
1051 current_inferior ()->num
);
1054 ui_out_redirect (uiout
, NULL
);
1056 gdb_flush (mi
->event_channel
);
1058 do_cleanups (old_chain
);
1062 mi_solib_unloaded (struct so_list
*solib
)
1064 struct mi_interp
*mi
= (struct mi_interp
*) top_level_interpreter_data ();
1065 struct ui_out
*uiout
= interp_ui_out (top_level_interpreter ());
1066 struct cleanup
*old_chain
;
1068 old_chain
= make_cleanup_restore_target_terminal ();
1069 target_terminal_ours_for_output ();
1071 fprintf_unfiltered (mi
->event_channel
, "library-unloaded");
1073 ui_out_redirect (uiout
, mi
->event_channel
);
1075 ui_out_field_string (uiout
, "id", solib
->so_original_name
);
1076 ui_out_field_string (uiout
, "target-name", solib
->so_original_name
);
1077 ui_out_field_string (uiout
, "host-name", solib
->so_name
);
1078 if (!gdbarch_has_global_solist (target_gdbarch ()))
1080 ui_out_field_fmt (uiout
, "thread-group", "i%d",
1081 current_inferior ()->num
);
1084 ui_out_redirect (uiout
, NULL
);
1086 gdb_flush (mi
->event_channel
);
1088 do_cleanups (old_chain
);
1091 /* Emit notification about the command parameter change. */
1094 mi_command_param_changed (const char *param
, const char *value
)
1096 struct mi_interp
*mi
= (struct mi_interp
*) top_level_interpreter_data ();
1097 struct ui_out
*mi_uiout
= interp_ui_out (top_level_interpreter ());
1098 struct cleanup
*old_chain
;
1100 if (mi_suppress_notification
.cmd_param_changed
)
1103 old_chain
= make_cleanup_restore_target_terminal ();
1104 target_terminal_ours_for_output ();
1106 fprintf_unfiltered (mi
->event_channel
,
1107 "cmd-param-changed");
1109 ui_out_redirect (mi_uiout
, mi
->event_channel
);
1111 ui_out_field_string (mi_uiout
, "param", param
);
1112 ui_out_field_string (mi_uiout
, "value", value
);
1114 ui_out_redirect (mi_uiout
, NULL
);
1116 gdb_flush (mi
->event_channel
);
1118 do_cleanups (old_chain
);
1121 /* Emit notification about the target memory change. */
1124 mi_memory_changed (struct inferior
*inferior
, CORE_ADDR memaddr
,
1125 ssize_t len
, const bfd_byte
*myaddr
)
1127 struct mi_interp
*mi
= (struct mi_interp
*) top_level_interpreter_data ();
1128 struct ui_out
*mi_uiout
= interp_ui_out (top_level_interpreter ());
1129 struct obj_section
*sec
;
1130 struct cleanup
*old_chain
;
1132 if (mi_suppress_notification
.memory
)
1135 old_chain
= make_cleanup_restore_target_terminal ();
1136 target_terminal_ours_for_output ();
1138 fprintf_unfiltered (mi
->event_channel
,
1141 ui_out_redirect (mi_uiout
, mi
->event_channel
);
1143 ui_out_field_fmt (mi_uiout
, "thread-group", "i%d", inferior
->num
);
1144 ui_out_field_core_addr (mi_uiout
, "addr", target_gdbarch (), memaddr
);
1145 ui_out_field_fmt (mi_uiout
, "len", "%s", hex_string (len
));
1147 /* Append 'type=code' into notification if MEMADDR falls in the range of
1148 sections contain code. */
1149 sec
= find_pc_section (memaddr
);
1150 if (sec
!= NULL
&& sec
->objfile
!= NULL
)
1152 flagword flags
= bfd_get_section_flags (sec
->objfile
->obfd
,
1153 sec
->the_bfd_section
);
1155 if (flags
& SEC_CODE
)
1156 ui_out_field_string (mi_uiout
, "type", "code");
1159 ui_out_redirect (mi_uiout
, NULL
);
1161 gdb_flush (mi
->event_channel
);
1163 do_cleanups (old_chain
);
1167 report_initial_inferior (struct inferior
*inf
, void *closure
)
1169 /* This function is called from mi_intepreter_init, and since
1170 mi_inferior_added assumes that inferior is fully initialized
1171 and top_level_interpreter_data is set, we cannot call
1173 struct mi_interp
*mi
= (struct mi_interp
*) closure
;
1174 struct cleanup
*old_chain
;
1176 old_chain
= make_cleanup_restore_target_terminal ();
1177 target_terminal_ours_for_output ();
1179 fprintf_unfiltered (mi
->event_channel
,
1180 "thread-group-added,id=\"i%d\"",
1182 gdb_flush (mi
->event_channel
);
1184 do_cleanups (old_chain
);
1188 static struct ui_out
*
1189 mi_ui_out (struct interp
*interp
)
1191 struct mi_interp
*mi
= (struct mi_interp
*) interp_data (interp
);
1193 return mi
->mi_uiout
;
1196 /* Save the original value of raw_stdout here when logging, so we can
1197 restore correctly when done. */
1199 static struct ui_file
*saved_raw_stdout
;
1201 /* Do MI-specific logging actions; save raw_stdout, and change all
1202 the consoles to use the supplied ui-file(s). */
1205 mi_set_logging (struct interp
*interp
, int start_log
,
1206 struct ui_file
*out
, struct ui_file
*logfile
)
1208 struct mi_interp
*mi
= (struct mi_interp
*) interp_data (interp
);
1215 /* The tee created already is based on gdb_stdout, which for MI
1216 is a console and so we end up in an infinite loop of console
1217 writing to ui_file writing to console etc. So discard the
1218 existing tee (it hasn't been used yet, and MI won't ever use
1219 it), and create one based on raw_stdout instead. */
1222 ui_file_delete (out
);
1223 out
= tee_file_new (raw_stdout
, 0, logfile
, 0);
1226 saved_raw_stdout
= raw_stdout
;
1231 raw_stdout
= saved_raw_stdout
;
1232 saved_raw_stdout
= NULL
;
1235 mi_console_set_raw (mi
->out
, raw_stdout
);
1236 mi_console_set_raw (mi
->err
, raw_stdout
);
1237 mi_console_set_raw (mi
->log
, raw_stdout
);
1238 mi_console_set_raw (mi
->targ
, raw_stdout
);
1239 mi_console_set_raw (mi
->event_channel
, raw_stdout
);
1244 extern initialize_file_ftype _initialize_mi_interp
; /* -Wmissing-prototypes */
1247 _initialize_mi_interp (void)
1249 static const struct interp_procs procs
=
1251 mi_interpreter_init
, /* init_proc */
1252 mi_interpreter_resume
, /* resume_proc */
1253 mi_interpreter_suspend
, /* suspend_proc */
1254 mi_interpreter_exec
, /* exec_proc */
1255 mi_ui_out
, /* ui_out_proc */
1256 mi_set_logging
, /* set_logging_proc */
1257 mi_command_loop
/* command_loop_proc */
1260 /* The various interpreter levels. */
1261 interp_add (interp_new (INTERP_MI1
, &procs
));
1262 interp_add (interp_new (INTERP_MI2
, &procs
));
1263 interp_add (interp_new (INTERP_MI3
, &procs
));
1264 interp_add (interp_new (INTERP_MI
, &procs
));