1 /* MI Interpreter Definitions and Commands for GDB, the GNU debugger.
3 Copyright (C) 2002-2015 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"
41 /* These are the interpreter setup, etc. functions for the MI
44 static void mi_execute_command_wrapper (const char *cmd
);
45 static void mi_execute_command_input_handler (char *cmd
);
46 static void mi_command_loop (void *data
);
48 /* These are hooks that we put in place while doing interpreter_exec
49 so we can report interesting things that happened "behind the MI's
50 back" in this command. */
52 static int mi_interp_query_hook (const char *ctlstr
, va_list ap
)
53 ATTRIBUTE_PRINTF (1, 0);
55 static void mi_insert_notify_hooks (void);
56 static void mi_remove_notify_hooks (void);
58 static void mi_on_signal_received (enum gdb_signal siggnal
);
59 static void mi_on_end_stepping_range (void);
60 static void mi_on_signal_exited (enum gdb_signal siggnal
);
61 static void mi_on_exited (int exitstatus
);
62 static void mi_on_normal_stop (struct bpstats
*bs
, int print_frame
);
63 static void mi_on_no_history (void);
65 static void mi_new_thread (struct thread_info
*t
);
66 static void mi_thread_exit (struct thread_info
*t
, int silent
);
67 static void mi_record_changed (struct inferior
*, int);
68 static void mi_inferior_added (struct inferior
*inf
);
69 static void mi_inferior_appeared (struct inferior
*inf
);
70 static void mi_inferior_exit (struct inferior
*inf
);
71 static void mi_inferior_removed (struct inferior
*inf
);
72 static void mi_on_resume (ptid_t ptid
);
73 static void mi_solib_loaded (struct so_list
*solib
);
74 static void mi_solib_unloaded (struct so_list
*solib
);
75 static void mi_about_to_proceed (void);
76 static void mi_traceframe_changed (int tfnum
, int tpnum
);
77 static void mi_tsv_created (const struct trace_state_variable
*tsv
);
78 static void mi_tsv_deleted (const struct trace_state_variable
*tsv
);
79 static void mi_tsv_modified (const struct trace_state_variable
*tsv
);
80 static void mi_breakpoint_created (struct breakpoint
*b
);
81 static void mi_breakpoint_deleted (struct breakpoint
*b
);
82 static void mi_breakpoint_modified (struct breakpoint
*b
);
83 static void mi_command_param_changed (const char *param
, const char *value
);
84 static void mi_memory_changed (struct inferior
*inf
, CORE_ADDR memaddr
,
85 ssize_t len
, const bfd_byte
*myaddr
);
86 static void mi_on_sync_execution_done (void);
88 static int report_initial_inferior (struct inferior
*inf
, void *closure
);
91 mi_interpreter_init (struct interp
*interp
, int top_level
)
93 struct mi_interp
*mi
= XNEW (struct mi_interp
);
97 /* Assign the output channel created at startup to its own global,
98 so that we can create a console channel that encapsulates and
99 prefixes all gdb_output-type bits coming from the rest of the
102 raw_stdout
= gdb_stdout
;
104 /* Create MI console channels, each with a different prefix so they
105 can be distinguished. */
106 mi
->out
= mi_console_file_new (raw_stdout
, "~", '"');
107 mi
->err
= mi_console_file_new (raw_stdout
, "&", '"');
109 mi
->targ
= mi_console_file_new (raw_stdout
, "@", '"');
110 mi
->event_channel
= mi_console_file_new (raw_stdout
, "=", 0);
112 name
= interp_name (interp
);
113 /* INTERP_MI selects the most recent released version. "mi2" was
114 released as part of GDB 6.0. */
115 if (strcmp (name
, INTERP_MI
) == 0)
117 else if (strcmp (name
, INTERP_MI1
) == 0)
119 else if (strcmp (name
, INTERP_MI2
) == 0)
121 else if (strcmp (name
, INTERP_MI3
) == 0)
124 gdb_assert_not_reached ("unhandled MI version");
126 mi
->mi_uiout
= mi_out_new (mi_version
);
127 mi
->cli_uiout
= cli_out_new (mi
->out
);
129 /* There are installed even if MI is not the top level interpreter.
130 The callbacks themselves decide whether to be skipped. */
131 observer_attach_signal_received (mi_on_signal_received
);
132 observer_attach_end_stepping_range (mi_on_end_stepping_range
);
133 observer_attach_signal_exited (mi_on_signal_exited
);
134 observer_attach_exited (mi_on_exited
);
135 observer_attach_no_history (mi_on_no_history
);
139 observer_attach_new_thread (mi_new_thread
);
140 observer_attach_thread_exit (mi_thread_exit
);
141 observer_attach_inferior_added (mi_inferior_added
);
142 observer_attach_inferior_appeared (mi_inferior_appeared
);
143 observer_attach_inferior_exit (mi_inferior_exit
);
144 observer_attach_inferior_removed (mi_inferior_removed
);
145 observer_attach_record_changed (mi_record_changed
);
146 observer_attach_normal_stop (mi_on_normal_stop
);
147 observer_attach_target_resumed (mi_on_resume
);
148 observer_attach_solib_loaded (mi_solib_loaded
);
149 observer_attach_solib_unloaded (mi_solib_unloaded
);
150 observer_attach_about_to_proceed (mi_about_to_proceed
);
151 observer_attach_traceframe_changed (mi_traceframe_changed
);
152 observer_attach_tsv_created (mi_tsv_created
);
153 observer_attach_tsv_deleted (mi_tsv_deleted
);
154 observer_attach_tsv_modified (mi_tsv_modified
);
155 observer_attach_breakpoint_created (mi_breakpoint_created
);
156 observer_attach_breakpoint_deleted (mi_breakpoint_deleted
);
157 observer_attach_breakpoint_modified (mi_breakpoint_modified
);
158 observer_attach_command_param_changed (mi_command_param_changed
);
159 observer_attach_memory_changed (mi_memory_changed
);
160 observer_attach_sync_execution_done (mi_on_sync_execution_done
);
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 /* Observer for the synchronous_command_done notification. */
310 mi_on_sync_execution_done (void)
312 /* MI generally prints a prompt after a command, indicating it's
313 ready for further input. However, due to an historical wart, if
314 MI async, and a (CLI) synchronous command was issued, then we
315 will print the prompt right after printing "^running", even if we
316 cannot actually accept any input until the target stops. See
317 mi_on_resume. However, if the target is async but MI is sync,
318 then we need to output the MI prompt now, to replicate gdb's
319 behavior when neither the target nor MI are async. (Note this
320 observer is only called by the asynchronous target event handling
324 fputs_unfiltered ("(gdb) \n", raw_stdout
);
325 gdb_flush (raw_stdout
);
329 /* mi_execute_command_wrapper wrapper suitable for INPUT_HANDLER. */
332 mi_execute_command_input_handler (char *cmd
)
334 mi_execute_command_wrapper (cmd
);
336 /* MI generally prints a prompt after a command, indicating it's
337 ready for further input. However, due to an historical wart, if
338 MI is async, and a synchronous command was issued, then we will
339 print the prompt right after printing "^running", even if we
340 cannot actually accept any input until the target stops. See
343 If MI is not async, then we print the prompt when the command
344 finishes. If the target is sync, that means output the prompt
345 now, as in that case executing a command doesn't return until the
346 command is done. However, if the target is async, we go back to
347 the event loop and output the prompt in the
348 'synchronous_command_done' observer. */
349 if (!target_is_async_p () || !sync_execution
)
351 fputs_unfiltered ("(gdb) \n", raw_stdout
);
352 gdb_flush (raw_stdout
);
357 mi_command_loop (void *data
)
359 /* Turn off 8 bit strings in quoted output. Any character with the
360 high bit set is printed using C's octal format. */
361 sevenbit_strings
= 1;
363 /* Tell the world that we're alive. */
364 fputs_unfiltered ("(gdb) \n", raw_stdout
);
365 gdb_flush (raw_stdout
);
371 mi_new_thread (struct thread_info
*t
)
373 struct mi_interp
*mi
= top_level_interpreter_data ();
374 struct inferior
*inf
= find_inferior_ptid (t
->ptid
);
378 fprintf_unfiltered (mi
->event_channel
,
379 "thread-created,id=\"%d\",group-id=\"i%d\"",
381 gdb_flush (mi
->event_channel
);
385 mi_thread_exit (struct thread_info
*t
, int silent
)
387 struct mi_interp
*mi
;
388 struct inferior
*inf
;
389 struct cleanup
*old_chain
;
394 inf
= find_inferior_ptid (t
->ptid
);
396 mi
= top_level_interpreter_data ();
397 old_chain
= make_cleanup_restore_target_terminal ();
398 target_terminal_ours ();
399 fprintf_unfiltered (mi
->event_channel
,
400 "thread-exited,id=\"%d\",group-id=\"i%d\"",
402 gdb_flush (mi
->event_channel
);
404 do_cleanups (old_chain
);
407 /* Emit notification on changing the state of record. */
410 mi_record_changed (struct inferior
*inferior
, int started
)
412 struct mi_interp
*mi
= top_level_interpreter_data ();
414 fprintf_unfiltered (mi
->event_channel
, "record-%s,thread-group=\"i%d\"",
415 started
? "started" : "stopped", inferior
->num
);
417 gdb_flush (mi
->event_channel
);
421 mi_inferior_added (struct inferior
*inf
)
423 struct mi_interp
*mi
= top_level_interpreter_data ();
425 target_terminal_ours ();
426 fprintf_unfiltered (mi
->event_channel
,
427 "thread-group-added,id=\"i%d\"",
429 gdb_flush (mi
->event_channel
);
433 mi_inferior_appeared (struct inferior
*inf
)
435 struct mi_interp
*mi
= top_level_interpreter_data ();
437 target_terminal_ours ();
438 fprintf_unfiltered (mi
->event_channel
,
439 "thread-group-started,id=\"i%d\",pid=\"%d\"",
441 gdb_flush (mi
->event_channel
);
445 mi_inferior_exit (struct inferior
*inf
)
447 struct mi_interp
*mi
= top_level_interpreter_data ();
449 target_terminal_ours ();
450 if (inf
->has_exit_code
)
451 fprintf_unfiltered (mi
->event_channel
,
452 "thread-group-exited,id=\"i%d\",exit-code=\"%s\"",
453 inf
->num
, int_string (inf
->exit_code
, 8, 0, 0, 1));
455 fprintf_unfiltered (mi
->event_channel
,
456 "thread-group-exited,id=\"i%d\"", inf
->num
);
458 gdb_flush (mi
->event_channel
);
462 mi_inferior_removed (struct inferior
*inf
)
464 struct mi_interp
*mi
= top_level_interpreter_data ();
466 target_terminal_ours ();
467 fprintf_unfiltered (mi
->event_channel
,
468 "thread-group-removed,id=\"i%d\"",
470 gdb_flush (mi
->event_channel
);
473 /* Cleanup that restores a previous current uiout. */
476 restore_current_uiout_cleanup (void *arg
)
478 struct ui_out
*saved_uiout
= arg
;
480 current_uiout
= saved_uiout
;
483 /* Return the MI interpreter, if it is active -- either because it's
484 the top-level interpreter or the interpreter executing the current
485 command. Returns NULL if the MI interpreter is not being used. */
487 static struct interp
*
488 find_mi_interpreter (void)
490 struct interp
*interp
;
492 interp
= top_level_interpreter ();
493 if (ui_out_is_mi_like_p (interp_ui_out (interp
)))
496 interp
= command_interp ();
497 if (ui_out_is_mi_like_p (interp_ui_out (interp
)))
503 /* Return the MI_INTERP structure of the active MI interpreter.
504 Returns NULL if MI is not active. */
506 static struct mi_interp
*
507 mi_interp_data (void)
509 struct interp
*interp
= find_mi_interpreter ();
512 return interp_data (interp
);
516 /* Observers for several run control events that print why the
517 inferior has stopped to both the the MI event channel and to the MI
518 console. If the MI interpreter is not active, print nothing. */
520 /* Observer for the signal_received notification. */
523 mi_on_signal_received (enum gdb_signal siggnal
)
525 struct mi_interp
*mi
= mi_interp_data ();
530 print_signal_received_reason (mi
->mi_uiout
, siggnal
);
531 print_signal_received_reason (mi
->cli_uiout
, siggnal
);
534 /* Observer for the end_stepping_range notification. */
537 mi_on_end_stepping_range (void)
539 struct mi_interp
*mi
= mi_interp_data ();
544 print_end_stepping_range_reason (mi
->mi_uiout
);
545 print_end_stepping_range_reason (mi
->cli_uiout
);
548 /* Observer for the signal_exited notification. */
551 mi_on_signal_exited (enum gdb_signal siggnal
)
553 struct mi_interp
*mi
= mi_interp_data ();
558 print_signal_exited_reason (mi
->mi_uiout
, siggnal
);
559 print_signal_exited_reason (mi
->cli_uiout
, siggnal
);
562 /* Observer for the exited notification. */
565 mi_on_exited (int exitstatus
)
567 struct mi_interp
*mi
= mi_interp_data ();
572 print_exited_reason (mi
->mi_uiout
, exitstatus
);
573 print_exited_reason (mi
->cli_uiout
, exitstatus
);
576 /* Observer for the no_history notification. */
579 mi_on_no_history (void)
581 struct mi_interp
*mi
= mi_interp_data ();
586 print_no_history_reason (mi
->mi_uiout
);
587 print_no_history_reason (mi
->cli_uiout
);
591 mi_on_normal_stop (struct bpstats
*bs
, int print_frame
)
593 /* Since this can be called when CLI command is executing,
594 using cli interpreter, be sure to use MI uiout for output,
595 not the current one. */
596 struct ui_out
*mi_uiout
= interp_ui_out (top_level_interpreter ());
602 if (current_uiout
!= mi_uiout
)
604 /* The normal_stop function has printed frame information
605 into CLI uiout, or some other non-MI uiout. There's no
606 way we can extract proper fields from random uiout
607 object, so we print the frame again. In practice, this
608 can only happen when running a CLI command in MI. */
609 struct ui_out
*saved_uiout
= current_uiout
;
610 struct target_waitstatus last
;
613 current_uiout
= mi_uiout
;
615 get_last_target_status (&last_ptid
, &last
);
616 print_stop_event (&last
);
618 current_uiout
= saved_uiout
;
620 /* Otherwise, frame information has already been printed by
624 /* Breakpoint hits should always be mirrored to the console.
625 Deciding what to mirror to the console wrt to breakpoints
626 and random stops gets messy real fast. E.g., say "s"
627 trips on a breakpoint. We'd clearly want to mirror the
628 event to the console in this case. But what about more
629 complicated cases like "s&; thread n; s&", and one of
630 those steps spawning a new thread, and that thread
631 hitting a breakpoint? It's impossible in general to
632 track whether the thread had any relation to the commands
633 that had been executed. So we just simplify and always
634 mirror breakpoints and random events to the console.
636 Also, CLI execution commands (-interpreter-exec console
637 "next", for example) in async mode have the opposite
638 issue as described in the "then" branch above --
639 normal_stop has already printed frame information to MI
640 uiout, but nothing has printed the same information to
641 the CLI channel. We should print the source line to the
642 console when stepping or other similar commands, iff the
643 step was started by a console command (but not if it was
644 started with -exec-step or similar). */
645 struct thread_info
*tp
= inferior_thread ();
647 if ((!tp
->control
.stop_step
648 && !tp
->control
.proceed_to_finish
)
649 || (tp
->control
.command_interp
!= NULL
650 && tp
->control
.command_interp
!= top_level_interpreter ()))
652 struct mi_interp
*mi
= top_level_interpreter_data ();
653 struct target_waitstatus last
;
655 struct cleanup
*old_chain
;
657 /* Set the current uiout to CLI uiout temporarily. */
658 old_chain
= make_cleanup (restore_current_uiout_cleanup
,
660 current_uiout
= mi
->cli_uiout
;
662 get_last_target_status (&last_ptid
, &last
);
663 print_stop_event (&last
);
665 do_cleanups (old_chain
);
669 ui_out_field_int (mi_uiout
, "thread-id",
670 pid_to_thread_id (inferior_ptid
));
673 struct cleanup
*back_to
= make_cleanup_ui_out_list_begin_end
674 (mi_uiout
, "stopped-threads");
676 ui_out_field_int (mi_uiout
, NULL
,
677 pid_to_thread_id (inferior_ptid
));
678 do_cleanups (back_to
);
681 ui_out_field_string (mi_uiout
, "stopped-threads", "all");
683 core
= target_core_of_thread (inferior_ptid
);
685 ui_out_field_int (mi_uiout
, "core", core
);
688 fputs_unfiltered ("*stopped", raw_stdout
);
689 mi_out_put (mi_uiout
, raw_stdout
);
690 mi_out_rewind (mi_uiout
);
691 mi_print_timing_maybe ();
692 fputs_unfiltered ("\n", raw_stdout
);
693 gdb_flush (raw_stdout
);
697 mi_about_to_proceed (void)
699 /* Suppress output while calling an inferior function. */
701 if (!ptid_equal (inferior_ptid
, null_ptid
))
703 struct thread_info
*tp
= inferior_thread ();
705 if (tp
->control
.in_infcall
)
712 /* When the element is non-zero, no MI notifications will be emitted in
713 response to the corresponding observers. */
715 struct mi_suppress_notification mi_suppress_notification
=
722 /* Emit notification on changing a traceframe. */
725 mi_traceframe_changed (int tfnum
, int tpnum
)
727 struct mi_interp
*mi
= top_level_interpreter_data ();
729 if (mi_suppress_notification
.traceframe
)
732 target_terminal_ours ();
735 fprintf_unfiltered (mi
->event_channel
, "traceframe-changed,"
736 "num=\"%d\",tracepoint=\"%d\"\n",
739 fprintf_unfiltered (mi
->event_channel
, "traceframe-changed,end");
741 gdb_flush (mi
->event_channel
);
744 /* Emit notification on creating a trace state variable. */
747 mi_tsv_created (const struct trace_state_variable
*tsv
)
749 struct mi_interp
*mi
= top_level_interpreter_data ();
751 target_terminal_ours ();
753 fprintf_unfiltered (mi
->event_channel
, "tsv-created,"
754 "name=\"%s\",initial=\"%s\"\n",
755 tsv
->name
, plongest (tsv
->initial_value
));
757 gdb_flush (mi
->event_channel
);
760 /* Emit notification on deleting a trace state variable. */
763 mi_tsv_deleted (const struct trace_state_variable
*tsv
)
765 struct mi_interp
*mi
= top_level_interpreter_data ();
767 target_terminal_ours ();
770 fprintf_unfiltered (mi
->event_channel
, "tsv-deleted,"
771 "name=\"%s\"\n", tsv
->name
);
773 fprintf_unfiltered (mi
->event_channel
, "tsv-deleted\n");
775 gdb_flush (mi
->event_channel
);
778 /* Emit notification on modifying a trace state variable. */
781 mi_tsv_modified (const struct trace_state_variable
*tsv
)
783 struct mi_interp
*mi
= top_level_interpreter_data ();
784 struct ui_out
*mi_uiout
= interp_ui_out (top_level_interpreter ());
786 target_terminal_ours ();
788 fprintf_unfiltered (mi
->event_channel
,
791 ui_out_redirect (mi_uiout
, mi
->event_channel
);
793 ui_out_field_string (mi_uiout
, "name", tsv
->name
);
794 ui_out_field_string (mi_uiout
, "initial",
795 plongest (tsv
->initial_value
));
796 if (tsv
->value_known
)
797 ui_out_field_string (mi_uiout
, "current", plongest (tsv
->value
));
799 ui_out_redirect (mi_uiout
, NULL
);
801 gdb_flush (mi
->event_channel
);
804 /* Emit notification about a created breakpoint. */
807 mi_breakpoint_created (struct breakpoint
*b
)
809 struct mi_interp
*mi
= top_level_interpreter_data ();
810 struct ui_out
*mi_uiout
= interp_ui_out (top_level_interpreter ());
812 if (mi_suppress_notification
.breakpoint
)
818 target_terminal_ours ();
819 fprintf_unfiltered (mi
->event_channel
,
820 "breakpoint-created");
821 /* We want the output from gdb_breakpoint_query to go to
822 mi->event_channel. One approach would be to just call
823 gdb_breakpoint_query, and then use mi_out_put to send the current
824 content of mi_outout into mi->event_channel. However, that will
825 break if anything is output to mi_uiout prior to calling the
826 breakpoint_created notifications. So, we use
828 ui_out_redirect (mi_uiout
, mi
->event_channel
);
831 gdb_breakpoint_query (mi_uiout
, b
->number
, NULL
);
833 CATCH (e
, RETURN_MASK_ERROR
)
838 ui_out_redirect (mi_uiout
, NULL
);
840 gdb_flush (mi
->event_channel
);
843 /* Emit notification about deleted breakpoint. */
846 mi_breakpoint_deleted (struct breakpoint
*b
)
848 struct mi_interp
*mi
= top_level_interpreter_data ();
850 if (mi_suppress_notification
.breakpoint
)
856 target_terminal_ours ();
858 fprintf_unfiltered (mi
->event_channel
, "breakpoint-deleted,id=\"%d\"",
861 gdb_flush (mi
->event_channel
);
864 /* Emit notification about modified breakpoint. */
867 mi_breakpoint_modified (struct breakpoint
*b
)
869 struct mi_interp
*mi
= top_level_interpreter_data ();
870 struct ui_out
*mi_uiout
= interp_ui_out (top_level_interpreter ());
872 if (mi_suppress_notification
.breakpoint
)
878 target_terminal_ours ();
879 fprintf_unfiltered (mi
->event_channel
,
880 "breakpoint-modified");
881 /* We want the output from gdb_breakpoint_query to go to
882 mi->event_channel. One approach would be to just call
883 gdb_breakpoint_query, and then use mi_out_put to send the current
884 content of mi_outout into mi->event_channel. However, that will
885 break if anything is output to mi_uiout prior to calling the
886 breakpoint_created notifications. So, we use
888 ui_out_redirect (mi_uiout
, mi
->event_channel
);
891 gdb_breakpoint_query (mi_uiout
, b
->number
, NULL
);
893 CATCH (e
, RETURN_MASK_ERROR
)
898 ui_out_redirect (mi_uiout
, NULL
);
900 gdb_flush (mi
->event_channel
);
904 mi_output_running_pid (struct thread_info
*info
, void *arg
)
908 if (ptid_get_pid (*ptid
) == ptid_get_pid (info
->ptid
))
909 fprintf_unfiltered (raw_stdout
,
910 "*running,thread-id=\"%d\"\n",
917 mi_inferior_count (struct inferior
*inf
, void *arg
)
929 mi_on_resume (ptid_t ptid
)
931 struct thread_info
*tp
= NULL
;
933 if (ptid_equal (ptid
, minus_one_ptid
) || ptid_is_pid (ptid
))
934 tp
= inferior_thread ();
936 tp
= find_thread_ptid (ptid
);
938 /* Suppress output while calling an inferior function. */
939 if (tp
->control
.in_infcall
)
942 /* To cater for older frontends, emit ^running, but do it only once
943 per each command. We do it here, since at this point we know
944 that the target was successfully resumed, and in non-async mode,
945 we won't return back to MI interpreter code until the target
946 is done running, so delaying the output of "^running" until then
947 will make it impossible for frontend to know what's going on.
949 In future (MI3), we'll be outputting "^done" here. */
950 if (!running_result_record_printed
&& mi_proceeded
)
952 fprintf_unfiltered (raw_stdout
, "%s^running\n",
953 current_token
? current_token
: "");
956 if (ptid_get_pid (ptid
) == -1)
957 fprintf_unfiltered (raw_stdout
, "*running,thread-id=\"all\"\n");
958 else if (ptid_is_pid (ptid
))
962 /* Backwards compatibility. If there's only one inferior,
963 output "all", otherwise, output each resumed thread
965 iterate_over_inferiors (mi_inferior_count
, &count
);
968 fprintf_unfiltered (raw_stdout
, "*running,thread-id=\"all\"\n");
970 iterate_over_threads (mi_output_running_pid
, &ptid
);
974 struct thread_info
*ti
= find_thread_ptid (ptid
);
977 fprintf_unfiltered (raw_stdout
, "*running,thread-id=\"%d\"\n", ti
->num
);
980 if (!running_result_record_printed
&& mi_proceeded
)
982 running_result_record_printed
= 1;
983 /* This is what gdb used to do historically -- printing prompt even if
984 it cannot actually accept any input. This will be surely removed
985 for MI3, and may be removed even earlier. SYNC_EXECUTION is
986 checked here because we only need to emit a prompt if a
987 synchronous command was issued when the target is async. */
988 if (!target_is_async_p () || sync_execution
)
989 fputs_unfiltered ("(gdb) \n", raw_stdout
);
991 gdb_flush (raw_stdout
);
995 mi_solib_loaded (struct so_list
*solib
)
997 struct mi_interp
*mi
= top_level_interpreter_data ();
998 struct ui_out
*uiout
= interp_ui_out (top_level_interpreter ());
1000 target_terminal_ours ();
1002 fprintf_unfiltered (mi
->event_channel
, "library-loaded");
1004 ui_out_redirect (uiout
, mi
->event_channel
);
1006 ui_out_field_string (uiout
, "id", solib
->so_original_name
);
1007 ui_out_field_string (uiout
, "target-name", solib
->so_original_name
);
1008 ui_out_field_string (uiout
, "host-name", solib
->so_name
);
1009 ui_out_field_int (uiout
, "symbols-loaded", solib
->symbols_loaded
);
1010 if (!gdbarch_has_global_solist (target_gdbarch ()))
1012 ui_out_field_fmt (uiout
, "thread-group", "i%d", current_inferior ()->num
);
1015 ui_out_redirect (uiout
, NULL
);
1017 gdb_flush (mi
->event_channel
);
1021 mi_solib_unloaded (struct so_list
*solib
)
1023 struct mi_interp
*mi
= top_level_interpreter_data ();
1024 struct ui_out
*uiout
= interp_ui_out (top_level_interpreter ());
1026 target_terminal_ours ();
1028 fprintf_unfiltered (mi
->event_channel
, "library-unloaded");
1030 ui_out_redirect (uiout
, mi
->event_channel
);
1032 ui_out_field_string (uiout
, "id", solib
->so_original_name
);
1033 ui_out_field_string (uiout
, "target-name", solib
->so_original_name
);
1034 ui_out_field_string (uiout
, "host-name", solib
->so_name
);
1035 if (!gdbarch_has_global_solist (target_gdbarch ()))
1037 ui_out_field_fmt (uiout
, "thread-group", "i%d", current_inferior ()->num
);
1040 ui_out_redirect (uiout
, NULL
);
1042 gdb_flush (mi
->event_channel
);
1045 /* Emit notification about the command parameter change. */
1048 mi_command_param_changed (const char *param
, const char *value
)
1050 struct mi_interp
*mi
= top_level_interpreter_data ();
1051 struct ui_out
*mi_uiout
= interp_ui_out (top_level_interpreter ());
1053 if (mi_suppress_notification
.cmd_param_changed
)
1056 target_terminal_ours ();
1058 fprintf_unfiltered (mi
->event_channel
,
1059 "cmd-param-changed");
1061 ui_out_redirect (mi_uiout
, mi
->event_channel
);
1063 ui_out_field_string (mi_uiout
, "param", param
);
1064 ui_out_field_string (mi_uiout
, "value", value
);
1066 ui_out_redirect (mi_uiout
, NULL
);
1068 gdb_flush (mi
->event_channel
);
1071 /* Emit notification about the target memory change. */
1074 mi_memory_changed (struct inferior
*inferior
, CORE_ADDR memaddr
,
1075 ssize_t len
, const bfd_byte
*myaddr
)
1077 struct mi_interp
*mi
= top_level_interpreter_data ();
1078 struct ui_out
*mi_uiout
= interp_ui_out (top_level_interpreter ());
1079 struct obj_section
*sec
;
1081 if (mi_suppress_notification
.memory
)
1084 target_terminal_ours ();
1086 fprintf_unfiltered (mi
->event_channel
,
1089 ui_out_redirect (mi_uiout
, mi
->event_channel
);
1091 ui_out_field_fmt (mi_uiout
, "thread-group", "i%d", inferior
->num
);
1092 ui_out_field_core_addr (mi_uiout
, "addr", target_gdbarch (), memaddr
);
1093 ui_out_field_fmt (mi_uiout
, "len", "%s", hex_string (len
));
1095 /* Append 'type=code' into notification if MEMADDR falls in the range of
1096 sections contain code. */
1097 sec
= find_pc_section (memaddr
);
1098 if (sec
!= NULL
&& sec
->objfile
!= NULL
)
1100 flagword flags
= bfd_get_section_flags (sec
->objfile
->obfd
,
1101 sec
->the_bfd_section
);
1103 if (flags
& SEC_CODE
)
1104 ui_out_field_string (mi_uiout
, "type", "code");
1107 ui_out_redirect (mi_uiout
, NULL
);
1109 gdb_flush (mi
->event_channel
);
1113 report_initial_inferior (struct inferior
*inf
, void *closure
)
1115 /* This function is called from mi_intepreter_init, and since
1116 mi_inferior_added assumes that inferior is fully initialized
1117 and top_level_interpreter_data is set, we cannot call
1119 struct mi_interp
*mi
= closure
;
1121 target_terminal_ours ();
1122 fprintf_unfiltered (mi
->event_channel
,
1123 "thread-group-added,id=\"i%d\"",
1125 gdb_flush (mi
->event_channel
);
1129 static struct ui_out
*
1130 mi_ui_out (struct interp
*interp
)
1132 struct mi_interp
*mi
= interp_data (interp
);
1134 return mi
->mi_uiout
;
1137 /* Save the original value of raw_stdout here when logging, so we can
1138 restore correctly when done. */
1140 static struct ui_file
*saved_raw_stdout
;
1142 /* Do MI-specific logging actions; save raw_stdout, and change all
1143 the consoles to use the supplied ui-file(s). */
1146 mi_set_logging (struct interp
*interp
, int start_log
,
1147 struct ui_file
*out
, struct ui_file
*logfile
)
1149 struct mi_interp
*mi
= interp_data (interp
);
1156 /* The tee created already is based on gdb_stdout, which for MI
1157 is a console and so we end up in an infinite loop of console
1158 writing to ui_file writing to console etc. So discard the
1159 existing tee (it hasn't been used yet, and MI won't ever use
1160 it), and create one based on raw_stdout instead. */
1163 ui_file_delete (out
);
1164 out
= tee_file_new (raw_stdout
, 0, logfile
, 0);
1167 saved_raw_stdout
= raw_stdout
;
1172 raw_stdout
= saved_raw_stdout
;
1173 saved_raw_stdout
= NULL
;
1176 mi_console_set_raw (mi
->out
, raw_stdout
);
1177 mi_console_set_raw (mi
->err
, raw_stdout
);
1178 mi_console_set_raw (mi
->log
, raw_stdout
);
1179 mi_console_set_raw (mi
->targ
, raw_stdout
);
1180 mi_console_set_raw (mi
->event_channel
, raw_stdout
);
1185 extern initialize_file_ftype _initialize_mi_interp
; /* -Wmissing-prototypes */
1188 _initialize_mi_interp (void)
1190 static const struct interp_procs procs
=
1192 mi_interpreter_init
, /* init_proc */
1193 mi_interpreter_resume
, /* resume_proc */
1194 mi_interpreter_suspend
, /* suspend_proc */
1195 mi_interpreter_exec
, /* exec_proc */
1196 mi_ui_out
, /* ui_out_proc */
1197 mi_set_logging
, /* set_logging_proc */
1198 mi_command_loop
/* command_loop_proc */
1201 /* The various interpreter levels. */
1202 interp_add (interp_new (INTERP_MI1
, &procs
));
1203 interp_add (interp_new (INTERP_MI2
, &procs
));
1204 interp_add (interp_new (INTERP_MI3
, &procs
));
1205 interp_add (interp_new (INTERP_MI
, &procs
));