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/>. */
22 #include "event-top.h"
23 #include "event-loop.h"
28 #include "exceptions.h"
32 #include "mi-console.h"
33 #include "mi-common.h"
35 #include "gdbthread.h"
39 #include "tracepoint.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);
69 static void mi_inferior_added (struct inferior
*inf
);
70 static void mi_inferior_appeared (struct inferior
*inf
);
71 static void mi_inferior_exit (struct inferior
*inf
);
72 static void mi_inferior_removed (struct inferior
*inf
);
73 static void mi_on_resume (ptid_t ptid
);
74 static void mi_solib_loaded (struct so_list
*solib
);
75 static void mi_solib_unloaded (struct so_list
*solib
);
76 static void mi_about_to_proceed (void);
77 static void mi_traceframe_changed (int tfnum
, int tpnum
);
78 static void mi_tsv_created (const struct trace_state_variable
*tsv
);
79 static void mi_tsv_deleted (const struct trace_state_variable
*tsv
);
80 static void mi_tsv_modified (const struct trace_state_variable
*tsv
);
81 static void mi_breakpoint_created (struct breakpoint
*b
);
82 static void mi_breakpoint_deleted (struct breakpoint
*b
);
83 static void mi_breakpoint_modified (struct breakpoint
*b
);
84 static void mi_command_param_changed (const char *param
, const char *value
);
85 static void mi_memory_changed (struct inferior
*inf
, CORE_ADDR memaddr
,
86 ssize_t len
, const bfd_byte
*myaddr
);
87 static void mi_on_sync_execution_done (void);
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
);
161 observer_attach_sync_execution_done (mi_on_sync_execution_done
);
163 /* The initial inferior is created before this function is
164 called, so we need to report it explicitly. Use iteration in
165 case future version of GDB creates more than one inferior
167 iterate_over_inferiors (report_initial_inferior
, mi
);
174 mi_interpreter_resume (void *data
)
176 struct mi_interp
*mi
= data
;
178 /* As per hack note in mi_interpreter_init, swap in the output
180 gdb_setup_readline ();
182 /* These overwrite some of the initialization done in
183 _intialize_event_loop. */
184 call_readline
= gdb_readline2
;
185 input_handler
= mi_execute_command_input_handler
;
186 async_command_editing_p
= 0;
187 /* FIXME: This is a total hack for now. PB's use of the MI
188 implicitly relies on a bug in the async support which allows
189 asynchronous commands to leak through the commmand loop. The bug
190 involves (but is not limited to) the fact that sync_execution was
191 erroneously initialized to 0. Duplicate by initializing it thus
195 gdb_stdout
= mi
->out
;
196 /* Route error and log output through the MI. */
197 gdb_stderr
= mi
->err
;
198 gdb_stdlog
= mi
->log
;
199 /* Route target output through the MI. */
200 gdb_stdtarg
= mi
->targ
;
201 /* Route target error through the MI as well. */
202 gdb_stdtargerr
= mi
->targ
;
204 /* Replace all the hooks that we know about. There really needs to
205 be a better way of doing this... */
206 clear_interpreter_hooks ();
208 deprecated_show_load_progress
= mi_load_progress
;
214 mi_interpreter_suspend (void *data
)
216 gdb_disable_readline ();
220 static struct gdb_exception
221 mi_interpreter_exec (void *data
, const char *command
)
223 mi_execute_command_wrapper (command
);
224 return exception_none
;
228 mi_cmd_interpreter_exec (char *command
, char **argv
, int argc
)
230 struct interp
*interp_to_use
;
232 char *mi_error_message
= NULL
;
233 struct cleanup
*old_chain
;
236 error (_("-interpreter-exec: "
237 "Usage: -interpreter-exec interp command"));
239 interp_to_use
= interp_lookup (argv
[0]);
240 if (interp_to_use
== NULL
)
241 error (_("-interpreter-exec: could not find interpreter \"%s\""),
244 /* Note that unlike the CLI version of this command, we don't
245 actually set INTERP_TO_USE as the current interpreter, as we
246 still want gdb_stdout, etc. to point at MI streams. */
248 /* Insert the MI out hooks, making sure to also call the
249 interpreter's hooks if it has any. */
250 /* KRS: We shouldn't need this... Events should be installed and
251 they should just ALWAYS fire something out down the MI
253 mi_insert_notify_hooks ();
255 /* Now run the code. */
257 old_chain
= make_cleanup (null_cleanup
, 0);
258 for (i
= 1; i
< argc
; i
++)
260 struct gdb_exception e
= interp_exec (interp_to_use
, argv
[i
]);
264 mi_error_message
= xstrdup (e
.message
);
265 make_cleanup (xfree
, mi_error_message
);
270 mi_remove_notify_hooks ();
272 if (mi_error_message
!= NULL
)
273 error ("%s", mi_error_message
);
274 do_cleanups (old_chain
);
277 /* This inserts a number of hooks that are meant to produce
278 async-notify ("=") MI messages while running commands in another
279 interpreter using mi_interpreter_exec. The canonical use for this
280 is to allow access to the gdb CLI interpreter from within the MI,
281 while still producing MI style output when actions in the CLI
282 command change GDB's state. */
285 mi_insert_notify_hooks (void)
287 deprecated_query_hook
= mi_interp_query_hook
;
291 mi_remove_notify_hooks (void)
293 deprecated_query_hook
= NULL
;
297 mi_interp_query_hook (const char *ctlstr
, va_list ap
)
303 mi_execute_command_wrapper (const char *cmd
)
305 mi_execute_command (cmd
, stdin
== instream
);
308 /* Observer for the synchronous_command_done notification. */
311 mi_on_sync_execution_done (void)
313 /* MI generally prints a prompt after a command, indicating it's
314 ready for further input. However, due to an historical wart, if
315 MI async, and a (CLI) synchronous command was issued, then we
316 will print the prompt right after printing "^running", even if we
317 cannot actually accept any input until the target stops. See
318 mi_on_resume. However, if the target is async but MI is sync,
319 then we need to output the MI prompt now, to replicate gdb's
320 behavior when neither the target nor MI are async. (Note this
321 observer is only called by the asynchronous target event handling
325 fputs_unfiltered ("(gdb) \n", raw_stdout
);
326 gdb_flush (raw_stdout
);
330 /* mi_execute_command_wrapper wrapper suitable for INPUT_HANDLER. */
333 mi_execute_command_input_handler (char *cmd
)
335 mi_execute_command_wrapper (cmd
);
337 /* MI generally prints a prompt after a command, indicating it's
338 ready for further input. However, due to an historical wart, if
339 MI is async, and a synchronous command was issued, then we will
340 print the prompt right after printing "^running", even if we
341 cannot actually accept any input until the target stops. See
344 If MI is not async, then we print the prompt when the command
345 finishes. If the target is sync, that means output the prompt
346 now, as in that case executing a command doesn't return until the
347 command is done. However, if the target is async, we go back to
348 the event loop and output the prompt in the
349 'synchronous_command_done' observer. */
350 if (!target_is_async_p () || !sync_execution
)
352 fputs_unfiltered ("(gdb) \n", raw_stdout
);
353 gdb_flush (raw_stdout
);
358 mi_command_loop (void *data
)
360 /* Turn off 8 bit strings in quoted output. Any character with the
361 high bit set is printed using C's octal format. */
362 sevenbit_strings
= 1;
364 /* Tell the world that we're alive. */
365 fputs_unfiltered ("(gdb) \n", raw_stdout
);
366 gdb_flush (raw_stdout
);
372 mi_new_thread (struct thread_info
*t
)
374 struct mi_interp
*mi
= top_level_interpreter_data ();
375 struct inferior
*inf
= find_inferior_pid (ptid_get_pid (t
->ptid
));
379 fprintf_unfiltered (mi
->event_channel
,
380 "thread-created,id=\"%d\",group-id=\"i%d\"",
382 gdb_flush (mi
->event_channel
);
386 mi_thread_exit (struct thread_info
*t
, int silent
)
388 struct mi_interp
*mi
;
389 struct inferior
*inf
;
394 inf
= find_inferior_pid (ptid_get_pid (t
->ptid
));
396 mi
= top_level_interpreter_data ();
397 target_terminal_ours ();
398 fprintf_unfiltered (mi
->event_channel
,
399 "thread-exited,id=\"%d\",group-id=\"i%d\"",
401 gdb_flush (mi
->event_channel
);
404 /* Emit notification on changing the state of record. */
407 mi_record_changed (struct inferior
*inferior
, int started
)
409 struct mi_interp
*mi
= top_level_interpreter_data ();
411 fprintf_unfiltered (mi
->event_channel
, "record-%s,thread-group=\"i%d\"",
412 started
? "started" : "stopped", inferior
->num
);
414 gdb_flush (mi
->event_channel
);
418 mi_inferior_added (struct inferior
*inf
)
420 struct mi_interp
*mi
= top_level_interpreter_data ();
422 target_terminal_ours ();
423 fprintf_unfiltered (mi
->event_channel
,
424 "thread-group-added,id=\"i%d\"",
426 gdb_flush (mi
->event_channel
);
430 mi_inferior_appeared (struct inferior
*inf
)
432 struct mi_interp
*mi
= top_level_interpreter_data ();
434 target_terminal_ours ();
435 fprintf_unfiltered (mi
->event_channel
,
436 "thread-group-started,id=\"i%d\",pid=\"%d\"",
438 gdb_flush (mi
->event_channel
);
442 mi_inferior_exit (struct inferior
*inf
)
444 struct mi_interp
*mi
= top_level_interpreter_data ();
446 target_terminal_ours ();
447 if (inf
->has_exit_code
)
448 fprintf_unfiltered (mi
->event_channel
,
449 "thread-group-exited,id=\"i%d\",exit-code=\"%s\"",
450 inf
->num
, int_string (inf
->exit_code
, 8, 0, 0, 1));
452 fprintf_unfiltered (mi
->event_channel
,
453 "thread-group-exited,id=\"i%d\"", inf
->num
);
455 gdb_flush (mi
->event_channel
);
459 mi_inferior_removed (struct inferior
*inf
)
461 struct mi_interp
*mi
= top_level_interpreter_data ();
463 target_terminal_ours ();
464 fprintf_unfiltered (mi
->event_channel
,
465 "thread-group-removed,id=\"i%d\"",
467 gdb_flush (mi
->event_channel
);
470 /* Cleanup that restores a previous current uiout. */
473 restore_current_uiout_cleanup (void *arg
)
475 struct ui_out
*saved_uiout
= arg
;
477 current_uiout
= saved_uiout
;
480 /* Return the MI interpreter, if it is active -- either because it's
481 the top-level interpreter or the interpreter executing the current
482 command. Returns NULL if the MI interpreter is not being used. */
484 static struct interp
*
485 find_mi_interpreter (void)
487 struct interp
*interp
;
489 interp
= top_level_interpreter ();
490 if (ui_out_is_mi_like_p (interp_ui_out (interp
)))
493 interp
= command_interp ();
494 if (ui_out_is_mi_like_p (interp_ui_out (interp
)))
500 /* Return the MI_INTERP structure of the active MI interpreter.
501 Returns NULL if MI is not active. */
503 static struct mi_interp
*
504 mi_interp_data (void)
506 struct interp
*interp
= find_mi_interpreter ();
509 return interp_data (interp
);
513 /* Observers for several run control events that print why the
514 inferior has stopped to both the the MI event channel and to the MI
515 console. If the MI interpreter is not active, print nothing. */
517 /* Observer for the signal_received notification. */
520 mi_on_signal_received (enum gdb_signal siggnal
)
522 struct mi_interp
*mi
= mi_interp_data ();
527 print_signal_received_reason (mi
->mi_uiout
, siggnal
);
528 print_signal_received_reason (mi
->cli_uiout
, siggnal
);
531 /* Observer for the end_stepping_range notification. */
534 mi_on_end_stepping_range (void)
536 struct mi_interp
*mi
= mi_interp_data ();
541 print_end_stepping_range_reason (mi
->mi_uiout
);
542 print_end_stepping_range_reason (mi
->cli_uiout
);
545 /* Observer for the signal_exited notification. */
548 mi_on_signal_exited (enum gdb_signal siggnal
)
550 struct mi_interp
*mi
= mi_interp_data ();
555 print_signal_exited_reason (mi
->mi_uiout
, siggnal
);
556 print_signal_exited_reason (mi
->cli_uiout
, siggnal
);
559 /* Observer for the exited notification. */
562 mi_on_exited (int exitstatus
)
564 struct mi_interp
*mi
= mi_interp_data ();
569 print_exited_reason (mi
->mi_uiout
, exitstatus
);
570 print_exited_reason (mi
->cli_uiout
, exitstatus
);
573 /* Observer for the no_history notification. */
576 mi_on_no_history (void)
578 struct mi_interp
*mi
= mi_interp_data ();
583 print_no_history_reason (mi
->mi_uiout
);
584 print_no_history_reason (mi
->cli_uiout
);
588 mi_on_normal_stop (struct bpstats
*bs
, int print_frame
)
590 /* Since this can be called when CLI command is executing,
591 using cli interpreter, be sure to use MI uiout for output,
592 not the current one. */
593 struct ui_out
*mi_uiout
= interp_ui_out (top_level_interpreter ());
599 if (current_uiout
!= mi_uiout
)
601 /* The normal_stop function has printed frame information
602 into CLI uiout, or some other non-MI uiout. There's no
603 way we can extract proper fields from random uiout
604 object, so we print the frame again. In practice, this
605 can only happen when running a CLI command in MI. */
606 struct ui_out
*saved_uiout
= current_uiout
;
607 struct target_waitstatus last
;
610 current_uiout
= mi_uiout
;
612 get_last_target_status (&last_ptid
, &last
);
613 print_stop_event (&last
);
615 current_uiout
= saved_uiout
;
617 /* Otherwise, frame information has already been printed by
621 /* Breakpoint hits should always be mirrored to the console.
622 Deciding what to mirror to the console wrt to breakpoints
623 and random stops gets messy real fast. E.g., say "s"
624 trips on a breakpoint. We'd clearly want to mirror the
625 event to the console in this case. But what about more
626 complicated cases like "s&; thread n; s&", and one of
627 those steps spawning a new thread, and that thread
628 hitting a breakpoint? It's impossible in general to
629 track whether the thread had any relation to the commands
630 that had been executed. So we just simplify and always
631 mirror breakpoints and random events to the console.
633 Also, CLI execution commands (-interpreter-exec console
634 "next", for example) in async mode have the opposite
635 issue as described in the "then" branch above --
636 normal_stop has already printed frame information to MI
637 uiout, but nothing has printed the same information to
638 the CLI channel. We should print the source line to the
639 console when stepping or other similar commands, iff the
640 step was started by a console command (but not if it was
641 started with -exec-step or similar). */
642 struct thread_info
*tp
= inferior_thread ();
644 if ((!tp
->control
.stop_step
645 && !tp
->control
.proceed_to_finish
)
646 || (tp
->control
.command_interp
!= NULL
647 && tp
->control
.command_interp
!= top_level_interpreter ()))
649 struct mi_interp
*mi
= top_level_interpreter_data ();
650 struct target_waitstatus last
;
652 struct cleanup
*old_chain
;
654 /* Set the current uiout to CLI uiout temporarily. */
655 old_chain
= make_cleanup (restore_current_uiout_cleanup
,
657 current_uiout
= mi
->cli_uiout
;
659 get_last_target_status (&last_ptid
, &last
);
660 print_stop_event (&last
);
662 do_cleanups (old_chain
);
666 ui_out_field_int (mi_uiout
, "thread-id",
667 pid_to_thread_id (inferior_ptid
));
670 struct cleanup
*back_to
= make_cleanup_ui_out_list_begin_end
671 (mi_uiout
, "stopped-threads");
673 ui_out_field_int (mi_uiout
, NULL
,
674 pid_to_thread_id (inferior_ptid
));
675 do_cleanups (back_to
);
678 ui_out_field_string (mi_uiout
, "stopped-threads", "all");
680 core
= target_core_of_thread (inferior_ptid
);
682 ui_out_field_int (mi_uiout
, "core", core
);
685 fputs_unfiltered ("*stopped", raw_stdout
);
686 mi_out_put (mi_uiout
, raw_stdout
);
687 mi_out_rewind (mi_uiout
);
688 mi_print_timing_maybe ();
689 fputs_unfiltered ("\n", raw_stdout
);
690 gdb_flush (raw_stdout
);
694 mi_about_to_proceed (void)
696 /* Suppress output while calling an inferior function. */
698 if (!ptid_equal (inferior_ptid
, null_ptid
))
700 struct thread_info
*tp
= inferior_thread ();
702 if (tp
->control
.in_infcall
)
709 /* When the element is non-zero, no MI notifications will be emitted in
710 response to the corresponding observers. */
712 struct mi_suppress_notification mi_suppress_notification
=
719 /* Emit notification on changing a traceframe. */
722 mi_traceframe_changed (int tfnum
, int tpnum
)
724 struct mi_interp
*mi
= top_level_interpreter_data ();
726 if (mi_suppress_notification
.traceframe
)
729 target_terminal_ours ();
732 fprintf_unfiltered (mi
->event_channel
, "traceframe-changed,"
733 "num=\"%d\",tracepoint=\"%d\"\n",
736 fprintf_unfiltered (mi
->event_channel
, "traceframe-changed,end");
738 gdb_flush (mi
->event_channel
);
741 /* Emit notification on creating a trace state variable. */
744 mi_tsv_created (const struct trace_state_variable
*tsv
)
746 struct mi_interp
*mi
= top_level_interpreter_data ();
748 target_terminal_ours ();
750 fprintf_unfiltered (mi
->event_channel
, "tsv-created,"
751 "name=\"%s\",initial=\"%s\"\n",
752 tsv
->name
, plongest (tsv
->initial_value
));
754 gdb_flush (mi
->event_channel
);
757 /* Emit notification on deleting a trace state variable. */
760 mi_tsv_deleted (const struct trace_state_variable
*tsv
)
762 struct mi_interp
*mi
= top_level_interpreter_data ();
764 target_terminal_ours ();
767 fprintf_unfiltered (mi
->event_channel
, "tsv-deleted,"
768 "name=\"%s\"\n", tsv
->name
);
770 fprintf_unfiltered (mi
->event_channel
, "tsv-deleted\n");
772 gdb_flush (mi
->event_channel
);
775 /* Emit notification on modifying a trace state variable. */
778 mi_tsv_modified (const struct trace_state_variable
*tsv
)
780 struct mi_interp
*mi
= top_level_interpreter_data ();
781 struct ui_out
*mi_uiout
= interp_ui_out (top_level_interpreter ());
783 target_terminal_ours ();
785 fprintf_unfiltered (mi
->event_channel
,
788 ui_out_redirect (mi_uiout
, mi
->event_channel
);
790 ui_out_field_string (mi_uiout
, "name", tsv
->name
);
791 ui_out_field_string (mi_uiout
, "initial",
792 plongest (tsv
->initial_value
));
793 if (tsv
->value_known
)
794 ui_out_field_string (mi_uiout
, "current", plongest (tsv
->value
));
796 ui_out_redirect (mi_uiout
, NULL
);
798 gdb_flush (mi
->event_channel
);
801 /* Emit notification about a created breakpoint. */
804 mi_breakpoint_created (struct breakpoint
*b
)
806 struct mi_interp
*mi
= top_level_interpreter_data ();
807 struct ui_out
*mi_uiout
= interp_ui_out (top_level_interpreter ());
808 volatile struct gdb_exception e
;
810 if (mi_suppress_notification
.breakpoint
)
816 target_terminal_ours ();
817 fprintf_unfiltered (mi
->event_channel
,
818 "breakpoint-created");
819 /* We want the output from gdb_breakpoint_query to go to
820 mi->event_channel. One approach would be to just call
821 gdb_breakpoint_query, and then use mi_out_put to send the current
822 content of mi_outout into mi->event_channel. However, that will
823 break if anything is output to mi_uiout prior to calling the
824 breakpoint_created notifications. So, we use
826 ui_out_redirect (mi_uiout
, mi
->event_channel
);
827 TRY_CATCH (e
, RETURN_MASK_ERROR
)
828 gdb_breakpoint_query (mi_uiout
, b
->number
, NULL
);
829 ui_out_redirect (mi_uiout
, NULL
);
831 gdb_flush (mi
->event_channel
);
834 /* Emit notification about deleted breakpoint. */
837 mi_breakpoint_deleted (struct breakpoint
*b
)
839 struct mi_interp
*mi
= top_level_interpreter_data ();
841 if (mi_suppress_notification
.breakpoint
)
847 target_terminal_ours ();
849 fprintf_unfiltered (mi
->event_channel
, "breakpoint-deleted,id=\"%d\"",
852 gdb_flush (mi
->event_channel
);
855 /* Emit notification about modified breakpoint. */
858 mi_breakpoint_modified (struct breakpoint
*b
)
860 struct mi_interp
*mi
= top_level_interpreter_data ();
861 struct ui_out
*mi_uiout
= interp_ui_out (top_level_interpreter ());
862 volatile struct gdb_exception e
;
864 if (mi_suppress_notification
.breakpoint
)
870 target_terminal_ours ();
871 fprintf_unfiltered (mi
->event_channel
,
872 "breakpoint-modified");
873 /* We want the output from gdb_breakpoint_query to go to
874 mi->event_channel. One approach would be to just call
875 gdb_breakpoint_query, and then use mi_out_put to send the current
876 content of mi_outout into mi->event_channel. However, that will
877 break if anything is output to mi_uiout prior to calling the
878 breakpoint_created notifications. So, we use
880 ui_out_redirect (mi_uiout
, mi
->event_channel
);
881 TRY_CATCH (e
, RETURN_MASK_ERROR
)
882 gdb_breakpoint_query (mi_uiout
, b
->number
, NULL
);
883 ui_out_redirect (mi_uiout
, NULL
);
885 gdb_flush (mi
->event_channel
);
889 mi_output_running_pid (struct thread_info
*info
, void *arg
)
893 if (ptid_get_pid (*ptid
) == ptid_get_pid (info
->ptid
))
894 fprintf_unfiltered (raw_stdout
,
895 "*running,thread-id=\"%d\"\n",
902 mi_inferior_count (struct inferior
*inf
, void *arg
)
914 mi_on_resume (ptid_t ptid
)
916 struct thread_info
*tp
= NULL
;
918 if (ptid_equal (ptid
, minus_one_ptid
) || ptid_is_pid (ptid
))
919 tp
= inferior_thread ();
921 tp
= find_thread_ptid (ptid
);
923 /* Suppress output while calling an inferior function. */
924 if (tp
->control
.in_infcall
)
927 /* To cater for older frontends, emit ^running, but do it only once
928 per each command. We do it here, since at this point we know
929 that the target was successfully resumed, and in non-async mode,
930 we won't return back to MI interpreter code until the target
931 is done running, so delaying the output of "^running" until then
932 will make it impossible for frontend to know what's going on.
934 In future (MI3), we'll be outputting "^done" here. */
935 if (!running_result_record_printed
&& mi_proceeded
)
937 fprintf_unfiltered (raw_stdout
, "%s^running\n",
938 current_token
? current_token
: "");
941 if (ptid_get_pid (ptid
) == -1)
942 fprintf_unfiltered (raw_stdout
, "*running,thread-id=\"all\"\n");
943 else if (ptid_is_pid (ptid
))
947 /* Backwards compatibility. If there's only one inferior,
948 output "all", otherwise, output each resumed thread
950 iterate_over_inferiors (mi_inferior_count
, &count
);
953 fprintf_unfiltered (raw_stdout
, "*running,thread-id=\"all\"\n");
955 iterate_over_threads (mi_output_running_pid
, &ptid
);
959 struct thread_info
*ti
= find_thread_ptid (ptid
);
962 fprintf_unfiltered (raw_stdout
, "*running,thread-id=\"%d\"\n", ti
->num
);
965 if (!running_result_record_printed
&& mi_proceeded
)
967 running_result_record_printed
= 1;
968 /* This is what gdb used to do historically -- printing prompt even if
969 it cannot actually accept any input. This will be surely removed
970 for MI3, and may be removed even earlier. SYNC_EXECUTION is
971 checked here because we only need to emit a prompt if a
972 synchronous command was issued when the target is async. */
973 if (!target_is_async_p () || sync_execution
)
974 fputs_unfiltered ("(gdb) \n", raw_stdout
);
976 gdb_flush (raw_stdout
);
980 mi_solib_loaded (struct so_list
*solib
)
982 struct mi_interp
*mi
= top_level_interpreter_data ();
983 struct ui_out
*uiout
= interp_ui_out (top_level_interpreter ());
985 target_terminal_ours ();
987 fprintf_unfiltered (mi
->event_channel
, "library-loaded");
989 ui_out_redirect (uiout
, mi
->event_channel
);
991 ui_out_field_string (uiout
, "id", solib
->so_original_name
);
992 ui_out_field_string (uiout
, "target-name", solib
->so_original_name
);
993 ui_out_field_string (uiout
, "host-name", solib
->so_name
);
994 ui_out_field_int (uiout
, "symbols-loaded", solib
->symbols_loaded
);
995 if (!gdbarch_has_global_solist (target_gdbarch ()))
997 ui_out_field_fmt (uiout
, "thread-group", "i%d", current_inferior ()->num
);
1000 ui_out_redirect (uiout
, NULL
);
1002 gdb_flush (mi
->event_channel
);
1006 mi_solib_unloaded (struct so_list
*solib
)
1008 struct mi_interp
*mi
= top_level_interpreter_data ();
1009 struct ui_out
*uiout
= interp_ui_out (top_level_interpreter ());
1011 target_terminal_ours ();
1013 fprintf_unfiltered (mi
->event_channel
, "library-unloaded");
1015 ui_out_redirect (uiout
, mi
->event_channel
);
1017 ui_out_field_string (uiout
, "id", solib
->so_original_name
);
1018 ui_out_field_string (uiout
, "target-name", solib
->so_original_name
);
1019 ui_out_field_string (uiout
, "host-name", solib
->so_name
);
1020 if (!gdbarch_has_global_solist (target_gdbarch ()))
1022 ui_out_field_fmt (uiout
, "thread-group", "i%d", current_inferior ()->num
);
1025 ui_out_redirect (uiout
, NULL
);
1027 gdb_flush (mi
->event_channel
);
1030 /* Emit notification about the command parameter change. */
1033 mi_command_param_changed (const char *param
, const char *value
)
1035 struct mi_interp
*mi
= top_level_interpreter_data ();
1036 struct ui_out
*mi_uiout
= interp_ui_out (top_level_interpreter ());
1038 if (mi_suppress_notification
.cmd_param_changed
)
1041 target_terminal_ours ();
1043 fprintf_unfiltered (mi
->event_channel
,
1044 "cmd-param-changed");
1046 ui_out_redirect (mi_uiout
, mi
->event_channel
);
1048 ui_out_field_string (mi_uiout
, "param", param
);
1049 ui_out_field_string (mi_uiout
, "value", value
);
1051 ui_out_redirect (mi_uiout
, NULL
);
1053 gdb_flush (mi
->event_channel
);
1056 /* Emit notification about the target memory change. */
1059 mi_memory_changed (struct inferior
*inferior
, CORE_ADDR memaddr
,
1060 ssize_t len
, const bfd_byte
*myaddr
)
1062 struct mi_interp
*mi
= top_level_interpreter_data ();
1063 struct ui_out
*mi_uiout
= interp_ui_out (top_level_interpreter ());
1064 struct obj_section
*sec
;
1066 if (mi_suppress_notification
.memory
)
1069 target_terminal_ours ();
1071 fprintf_unfiltered (mi
->event_channel
,
1074 ui_out_redirect (mi_uiout
, mi
->event_channel
);
1076 ui_out_field_fmt (mi_uiout
, "thread-group", "i%d", inferior
->num
);
1077 ui_out_field_core_addr (mi_uiout
, "addr", target_gdbarch (), memaddr
);
1078 ui_out_field_fmt (mi_uiout
, "len", "%s", hex_string (len
));
1080 /* Append 'type=code' into notification if MEMADDR falls in the range of
1081 sections contain code. */
1082 sec
= find_pc_section (memaddr
);
1083 if (sec
!= NULL
&& sec
->objfile
!= NULL
)
1085 flagword flags
= bfd_get_section_flags (sec
->objfile
->obfd
,
1086 sec
->the_bfd_section
);
1088 if (flags
& SEC_CODE
)
1089 ui_out_field_string (mi_uiout
, "type", "code");
1092 ui_out_redirect (mi_uiout
, NULL
);
1094 gdb_flush (mi
->event_channel
);
1098 report_initial_inferior (struct inferior
*inf
, void *closure
)
1100 /* This function is called from mi_intepreter_init, and since
1101 mi_inferior_added assumes that inferior is fully initialized
1102 and top_level_interpreter_data is set, we cannot call
1104 struct mi_interp
*mi
= closure
;
1106 target_terminal_ours ();
1107 fprintf_unfiltered (mi
->event_channel
,
1108 "thread-group-added,id=\"i%d\"",
1110 gdb_flush (mi
->event_channel
);
1114 static struct ui_out
*
1115 mi_ui_out (struct interp
*interp
)
1117 struct mi_interp
*mi
= interp_data (interp
);
1119 return mi
->mi_uiout
;
1122 /* Save the original value of raw_stdout here when logging, so we can
1123 restore correctly when done. */
1125 static struct ui_file
*saved_raw_stdout
;
1127 /* Do MI-specific logging actions; save raw_stdout, and change all
1128 the consoles to use the supplied ui-file(s). */
1131 mi_set_logging (struct interp
*interp
, int start_log
,
1132 struct ui_file
*out
, struct ui_file
*logfile
)
1134 struct mi_interp
*mi
= interp_data (interp
);
1141 /* The tee created already is based on gdb_stdout, which for MI
1142 is a console and so we end up in an infinite loop of console
1143 writing to ui_file writing to console etc. So discard the
1144 existing tee (it hasn't been used yet, and MI won't ever use
1145 it), and create one based on raw_stdout instead. */
1148 ui_file_delete (out
);
1149 out
= tee_file_new (raw_stdout
, 0, logfile
, 0);
1152 saved_raw_stdout
= raw_stdout
;
1157 raw_stdout
= saved_raw_stdout
;
1158 saved_raw_stdout
= NULL
;
1161 mi_console_set_raw (mi
->out
, raw_stdout
);
1162 mi_console_set_raw (mi
->err
, raw_stdout
);
1163 mi_console_set_raw (mi
->log
, raw_stdout
);
1164 mi_console_set_raw (mi
->targ
, raw_stdout
);
1165 mi_console_set_raw (mi
->event_channel
, raw_stdout
);
1170 extern initialize_file_ftype _initialize_mi_interp
; /* -Wmissing-prototypes */
1173 _initialize_mi_interp (void)
1175 static const struct interp_procs procs
=
1177 mi_interpreter_init
, /* init_proc */
1178 mi_interpreter_resume
, /* resume_proc */
1179 mi_interpreter_suspend
, /* suspend_proc */
1180 mi_interpreter_exec
, /* exec_proc */
1181 mi_ui_out
, /* ui_out_proc */
1182 mi_set_logging
, /* set_logging_proc */
1183 mi_command_loop
/* command_loop_proc */
1186 /* The various interpreter levels. */
1187 interp_add (interp_new (INTERP_MI1
, &procs
));
1188 interp_add (interp_new (INTERP_MI2
, &procs
));
1189 interp_add (interp_new (INTERP_MI3
, &procs
));
1190 interp_add (interp_new (INTERP_MI
, &procs
));