1 /* MI Interpreter Definitions and Commands for GDB, the GNU debugger.
3 Copyright (C) 2002-2014 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "event-top.h"
24 #include "event-loop.h"
29 #include "exceptions.h"
33 #include "mi-console.h"
34 #include "mi-common.h"
36 #include "gdbthread.h"
40 #include "tracepoint.h"
43 /* These are the interpreter setup, etc. functions for the MI
46 static void mi_execute_command_wrapper (const char *cmd
);
47 static void mi_execute_command_input_handler (char *cmd
);
48 static void mi_command_loop (void *data
);
50 /* These are hooks that we put in place while doing interpreter_exec
51 so we can report interesting things that happened "behind the MI's
52 back" in this command. */
54 static int mi_interp_query_hook (const char *ctlstr
, va_list ap
)
55 ATTRIBUTE_PRINTF (1, 0);
57 static void mi_insert_notify_hooks (void);
58 static void mi_remove_notify_hooks (void);
60 static void mi_on_signal_received (enum gdb_signal siggnal
);
61 static void mi_on_end_stepping_range (void);
62 static void mi_on_signal_exited (enum gdb_signal siggnal
);
63 static void mi_on_exited (int exitstatus
);
64 static void mi_on_normal_stop (struct bpstats
*bs
, int print_frame
);
65 static void mi_on_no_history (void);
67 static void mi_new_thread (struct thread_info
*t
);
68 static void mi_thread_exit (struct thread_info
*t
, int silent
);
69 static void mi_record_changed (struct inferior
*, int);
70 static void mi_inferior_added (struct inferior
*inf
);
71 static void mi_inferior_appeared (struct inferior
*inf
);
72 static void mi_inferior_exit (struct inferior
*inf
);
73 static void mi_inferior_removed (struct inferior
*inf
);
74 static void mi_on_resume (ptid_t ptid
);
75 static void mi_solib_loaded (struct so_list
*solib
);
76 static void mi_solib_unloaded (struct so_list
*solib
);
77 static void mi_about_to_proceed (void);
78 static void mi_traceframe_changed (int tfnum
, int tpnum
);
79 static void mi_tsv_created (const struct trace_state_variable
*tsv
);
80 static void mi_tsv_deleted (const struct trace_state_variable
*tsv
);
81 static void mi_tsv_modified (const struct trace_state_variable
*tsv
);
82 static void mi_breakpoint_created (struct breakpoint
*b
);
83 static void mi_breakpoint_deleted (struct breakpoint
*b
);
84 static void mi_breakpoint_modified (struct breakpoint
*b
);
85 static void mi_command_param_changed (const char *param
, const char *value
);
86 static void mi_memory_changed (struct inferior
*inf
, CORE_ADDR memaddr
,
87 ssize_t len
, const bfd_byte
*myaddr
);
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
= 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_readline2
;
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 /* MI generally prints a prompt after a command, indicating it's
315 ready for further input. However, due to an historical wart, if
316 MI async, and a (CLI) synchronous command was issued, then we
317 will print the prompt right after printing "^running", even if we
318 cannot actually accept any input until the target stops. See
319 mi_on_resume. However, if the target is async but MI is sync,
320 then we need to output the MI prompt now, to replicate gdb's
321 behavior when neither the target nor MI are async. (Note this
322 observer is only called by the asynchronous target event handling
326 fputs_unfiltered ("(gdb) \n", raw_stdout
);
327 gdb_flush (raw_stdout
);
331 /* mi_execute_command_wrapper wrapper suitable for INPUT_HANDLER. */
334 mi_execute_command_input_handler (char *cmd
)
336 mi_execute_command_wrapper (cmd
);
338 /* MI generally prints a prompt after a command, indicating it's
339 ready for further input. However, due to an historical wart, if
340 MI is async, and a synchronous command was issued, then we will
341 print the prompt right after printing "^running", even if we
342 cannot actually accept any input until the target stops. See
345 If MI is not async, then we print the prompt when the command
346 finishes. If the target is sync, that means output the prompt
347 now, as in that case executing a command doesn't return until the
348 command is done. However, if the target is async, we go back to
349 the event loop and output the prompt in the
350 'synchronous_command_done' observer. */
351 if (!target_is_async_p () || !sync_execution
)
353 fputs_unfiltered ("(gdb) \n", raw_stdout
);
354 gdb_flush (raw_stdout
);
359 mi_command_loop (void *data
)
361 /* Turn off 8 bit strings in quoted output. Any character with the
362 high bit set is printed using C's octal format. */
363 sevenbit_strings
= 1;
365 /* Tell the world that we're alive. */
366 fputs_unfiltered ("(gdb) \n", raw_stdout
);
367 gdb_flush (raw_stdout
);
373 mi_new_thread (struct thread_info
*t
)
375 struct mi_interp
*mi
= top_level_interpreter_data ();
376 struct inferior
*inf
= find_inferior_pid (ptid_get_pid (t
->ptid
));
380 fprintf_unfiltered (mi
->event_channel
,
381 "thread-created,id=\"%d\",group-id=\"i%d\"",
383 gdb_flush (mi
->event_channel
);
387 mi_thread_exit (struct thread_info
*t
, int silent
)
389 struct mi_interp
*mi
;
390 struct inferior
*inf
;
395 inf
= find_inferior_pid (ptid_get_pid (t
->ptid
));
397 mi
= top_level_interpreter_data ();
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
);
405 /* Emit notification on changing the state of record. */
408 mi_record_changed (struct inferior
*inferior
, int started
)
410 struct mi_interp
*mi
= top_level_interpreter_data ();
412 fprintf_unfiltered (mi
->event_channel
, "record-%s,thread-group=\"i%d\"",
413 started
? "started" : "stopped", inferior
->num
);
415 gdb_flush (mi
->event_channel
);
419 mi_inferior_added (struct inferior
*inf
)
421 struct mi_interp
*mi
= top_level_interpreter_data ();
423 target_terminal_ours ();
424 fprintf_unfiltered (mi
->event_channel
,
425 "thread-group-added,id=\"i%d\"",
427 gdb_flush (mi
->event_channel
);
431 mi_inferior_appeared (struct inferior
*inf
)
433 struct mi_interp
*mi
= top_level_interpreter_data ();
435 target_terminal_ours ();
436 fprintf_unfiltered (mi
->event_channel
,
437 "thread-group-started,id=\"i%d\",pid=\"%d\"",
439 gdb_flush (mi
->event_channel
);
443 mi_inferior_exit (struct inferior
*inf
)
445 struct mi_interp
*mi
= top_level_interpreter_data ();
447 target_terminal_ours ();
448 if (inf
->has_exit_code
)
449 fprintf_unfiltered (mi
->event_channel
,
450 "thread-group-exited,id=\"i%d\",exit-code=\"%s\"",
451 inf
->num
, int_string (inf
->exit_code
, 8, 0, 0, 1));
453 fprintf_unfiltered (mi
->event_channel
,
454 "thread-group-exited,id=\"i%d\"", inf
->num
);
456 gdb_flush (mi
->event_channel
);
460 mi_inferior_removed (struct inferior
*inf
)
462 struct mi_interp
*mi
= top_level_interpreter_data ();
464 target_terminal_ours ();
465 fprintf_unfiltered (mi
->event_channel
,
466 "thread-group-removed,id=\"i%d\"",
468 gdb_flush (mi
->event_channel
);
471 /* Cleanup that restores a previous current uiout. */
474 restore_current_uiout_cleanup (void *arg
)
476 struct ui_out
*saved_uiout
= arg
;
478 current_uiout
= saved_uiout
;
481 /* Return the MI interpreter, if it is active -- either because it's
482 the top-level interpreter or the interpreter executing the current
483 command. Returns NULL if the MI interpreter is not being used. */
485 static struct interp
*
486 find_mi_interpreter (void)
488 struct interp
*interp
;
490 interp
= top_level_interpreter ();
491 if (ui_out_is_mi_like_p (interp_ui_out (interp
)))
494 interp
= command_interp ();
495 if (ui_out_is_mi_like_p (interp_ui_out (interp
)))
501 /* Return the MI_INTERP structure of the active MI interpreter.
502 Returns NULL if MI is not active. */
504 static struct mi_interp
*
505 mi_interp_data (void)
507 struct interp
*interp
= find_mi_interpreter ();
510 return interp_data (interp
);
514 /* Observers for several run control events that print why the
515 inferior has stopped to both the the MI event channel and to the MI
516 console. If the MI interpreter is not active, print nothing. */
518 /* Observer for the signal_received notification. */
521 mi_on_signal_received (enum gdb_signal siggnal
)
523 struct mi_interp
*mi
= mi_interp_data ();
528 print_signal_received_reason (mi
->mi_uiout
, siggnal
);
529 print_signal_received_reason (mi
->cli_uiout
, siggnal
);
532 /* Observer for the end_stepping_range notification. */
535 mi_on_end_stepping_range (void)
537 struct mi_interp
*mi
= mi_interp_data ();
542 print_end_stepping_range_reason (mi
->mi_uiout
);
543 print_end_stepping_range_reason (mi
->cli_uiout
);
546 /* Observer for the signal_exited notification. */
549 mi_on_signal_exited (enum gdb_signal siggnal
)
551 struct mi_interp
*mi
= mi_interp_data ();
556 print_signal_exited_reason (mi
->mi_uiout
, siggnal
);
557 print_signal_exited_reason (mi
->cli_uiout
, siggnal
);
560 /* Observer for the exited notification. */
563 mi_on_exited (int exitstatus
)
565 struct mi_interp
*mi
= mi_interp_data ();
570 print_exited_reason (mi
->mi_uiout
, exitstatus
);
571 print_exited_reason (mi
->cli_uiout
, exitstatus
);
574 /* Observer for the no_history notification. */
577 mi_on_no_history (void)
579 struct mi_interp
*mi
= mi_interp_data ();
584 print_no_history_reason (mi
->mi_uiout
);
585 print_no_history_reason (mi
->cli_uiout
);
589 mi_on_normal_stop (struct bpstats
*bs
, int print_frame
)
591 /* Since this can be called when CLI command is executing,
592 using cli interpreter, be sure to use MI uiout for output,
593 not the current one. */
594 struct ui_out
*mi_uiout
= interp_ui_out (top_level_interpreter ());
600 if (current_uiout
!= mi_uiout
)
602 /* The normal_stop function has printed frame information
603 into CLI uiout, or some other non-MI uiout. There's no
604 way we can extract proper fields from random uiout
605 object, so we print the frame again. In practice, this
606 can only happen when running a CLI command in MI. */
607 struct ui_out
*saved_uiout
= current_uiout
;
608 struct target_waitstatus last
;
611 current_uiout
= mi_uiout
;
613 get_last_target_status (&last_ptid
, &last
);
614 print_stop_event (&last
);
616 current_uiout
= saved_uiout
;
618 /* Otherwise, frame information has already been printed by
622 /* Breakpoint hits should always be mirrored to the console.
623 Deciding what to mirror to the console wrt to breakpoints
624 and random stops gets messy real fast. E.g., say "s"
625 trips on a breakpoint. We'd clearly want to mirror the
626 event to the console in this case. But what about more
627 complicated cases like "s&; thread n; s&", and one of
628 those steps spawning a new thread, and that thread
629 hitting a breakpoint? It's impossible in general to
630 track whether the thread had any relation to the commands
631 that had been executed. So we just simplify and always
632 mirror breakpoints and random events to the console.
634 Also, CLI execution commands (-interpreter-exec console
635 "next", for example) in async mode have the opposite
636 issue as described in the "then" branch above --
637 normal_stop has already printed frame information to MI
638 uiout, but nothing has printed the same information to
639 the CLI channel. We should print the source line to the
640 console when stepping or other similar commands, iff the
641 step was started by a console command (but not if it was
642 started with -exec-step or similar). */
643 struct thread_info
*tp
= inferior_thread ();
645 if ((!tp
->control
.stop_step
646 && !tp
->control
.proceed_to_finish
)
647 || (tp
->control
.command_interp
!= NULL
648 && tp
->control
.command_interp
!= top_level_interpreter ()))
650 struct mi_interp
*mi
= top_level_interpreter_data ();
651 struct target_waitstatus last
;
653 struct cleanup
*old_chain
;
655 /* Set the current uiout to CLI uiout temporarily. */
656 old_chain
= make_cleanup (restore_current_uiout_cleanup
,
658 current_uiout
= mi
->cli_uiout
;
660 get_last_target_status (&last_ptid
, &last
);
661 print_stop_event (&last
);
663 do_cleanups (old_chain
);
667 ui_out_field_int (mi_uiout
, "thread-id",
668 pid_to_thread_id (inferior_ptid
));
671 struct cleanup
*back_to
= make_cleanup_ui_out_list_begin_end
672 (mi_uiout
, "stopped-threads");
674 ui_out_field_int (mi_uiout
, NULL
,
675 pid_to_thread_id (inferior_ptid
));
676 do_cleanups (back_to
);
679 ui_out_field_string (mi_uiout
, "stopped-threads", "all");
681 core
= target_core_of_thread (inferior_ptid
);
683 ui_out_field_int (mi_uiout
, "core", core
);
686 fputs_unfiltered ("*stopped", raw_stdout
);
687 mi_out_put (mi_uiout
, raw_stdout
);
688 mi_out_rewind (mi_uiout
);
689 mi_print_timing_maybe ();
690 fputs_unfiltered ("\n", raw_stdout
);
691 gdb_flush (raw_stdout
);
695 mi_about_to_proceed (void)
697 /* Suppress output while calling an inferior function. */
699 if (!ptid_equal (inferior_ptid
, null_ptid
))
701 struct thread_info
*tp
= inferior_thread ();
703 if (tp
->control
.in_infcall
)
710 /* When the element is non-zero, no MI notifications will be emitted in
711 response to the corresponding observers. */
713 struct mi_suppress_notification mi_suppress_notification
=
720 /* Emit notification on changing a traceframe. */
723 mi_traceframe_changed (int tfnum
, int tpnum
)
725 struct mi_interp
*mi
= top_level_interpreter_data ();
727 if (mi_suppress_notification
.traceframe
)
730 target_terminal_ours ();
733 fprintf_unfiltered (mi
->event_channel
, "traceframe-changed,"
734 "num=\"%d\",tracepoint=\"%d\"\n",
737 fprintf_unfiltered (mi
->event_channel
, "traceframe-changed,end");
739 gdb_flush (mi
->event_channel
);
742 /* Emit notification on creating a trace state variable. */
745 mi_tsv_created (const struct trace_state_variable
*tsv
)
747 struct mi_interp
*mi
= top_level_interpreter_data ();
749 target_terminal_ours ();
751 fprintf_unfiltered (mi
->event_channel
, "tsv-created,"
752 "name=\"%s\",initial=\"%s\"\n",
753 tsv
->name
, plongest (tsv
->initial_value
));
755 gdb_flush (mi
->event_channel
);
758 /* Emit notification on deleting a trace state variable. */
761 mi_tsv_deleted (const struct trace_state_variable
*tsv
)
763 struct mi_interp
*mi
= top_level_interpreter_data ();
765 target_terminal_ours ();
768 fprintf_unfiltered (mi
->event_channel
, "tsv-deleted,"
769 "name=\"%s\"\n", tsv
->name
);
771 fprintf_unfiltered (mi
->event_channel
, "tsv-deleted\n");
773 gdb_flush (mi
->event_channel
);
776 /* Emit notification on modifying a trace state variable. */
779 mi_tsv_modified (const struct trace_state_variable
*tsv
)
781 struct mi_interp
*mi
= top_level_interpreter_data ();
782 struct ui_out
*mi_uiout
= interp_ui_out (top_level_interpreter ());
784 target_terminal_ours ();
786 fprintf_unfiltered (mi
->event_channel
,
789 ui_out_redirect (mi_uiout
, mi
->event_channel
);
791 ui_out_field_string (mi_uiout
, "name", tsv
->name
);
792 ui_out_field_string (mi_uiout
, "initial",
793 plongest (tsv
->initial_value
));
794 if (tsv
->value_known
)
795 ui_out_field_string (mi_uiout
, "current", plongest (tsv
->value
));
797 ui_out_redirect (mi_uiout
, NULL
);
799 gdb_flush (mi
->event_channel
);
802 /* Emit notification about a created breakpoint. */
805 mi_breakpoint_created (struct breakpoint
*b
)
807 struct mi_interp
*mi
= top_level_interpreter_data ();
808 struct ui_out
*mi_uiout
= interp_ui_out (top_level_interpreter ());
809 volatile struct gdb_exception e
;
811 if (mi_suppress_notification
.breakpoint
)
817 target_terminal_ours ();
818 fprintf_unfiltered (mi
->event_channel
,
819 "breakpoint-created");
820 /* We want the output from gdb_breakpoint_query to go to
821 mi->event_channel. One approach would be to just call
822 gdb_breakpoint_query, and then use mi_out_put to send the current
823 content of mi_outout into mi->event_channel. However, that will
824 break if anything is output to mi_uiout prior to calling the
825 breakpoint_created notifications. So, we use
827 ui_out_redirect (mi_uiout
, mi
->event_channel
);
828 TRY_CATCH (e
, RETURN_MASK_ERROR
)
829 gdb_breakpoint_query (mi_uiout
, b
->number
, NULL
);
830 ui_out_redirect (mi_uiout
, NULL
);
832 gdb_flush (mi
->event_channel
);
835 /* Emit notification about deleted breakpoint. */
838 mi_breakpoint_deleted (struct breakpoint
*b
)
840 struct mi_interp
*mi
= top_level_interpreter_data ();
842 if (mi_suppress_notification
.breakpoint
)
848 target_terminal_ours ();
850 fprintf_unfiltered (mi
->event_channel
, "breakpoint-deleted,id=\"%d\"",
853 gdb_flush (mi
->event_channel
);
856 /* Emit notification about modified breakpoint. */
859 mi_breakpoint_modified (struct breakpoint
*b
)
861 struct mi_interp
*mi
= top_level_interpreter_data ();
862 struct ui_out
*mi_uiout
= interp_ui_out (top_level_interpreter ());
863 volatile struct gdb_exception e
;
865 if (mi_suppress_notification
.breakpoint
)
871 target_terminal_ours ();
872 fprintf_unfiltered (mi
->event_channel
,
873 "breakpoint-modified");
874 /* We want the output from gdb_breakpoint_query to go to
875 mi->event_channel. One approach would be to just call
876 gdb_breakpoint_query, and then use mi_out_put to send the current
877 content of mi_outout into mi->event_channel. However, that will
878 break if anything is output to mi_uiout prior to calling the
879 breakpoint_created notifications. So, we use
881 ui_out_redirect (mi_uiout
, mi
->event_channel
);
882 TRY_CATCH (e
, RETURN_MASK_ERROR
)
883 gdb_breakpoint_query (mi_uiout
, b
->number
, NULL
);
884 ui_out_redirect (mi_uiout
, NULL
);
886 gdb_flush (mi
->event_channel
);
890 mi_output_running_pid (struct thread_info
*info
, void *arg
)
894 if (ptid_get_pid (*ptid
) == ptid_get_pid (info
->ptid
))
895 fprintf_unfiltered (raw_stdout
,
896 "*running,thread-id=\"%d\"\n",
903 mi_inferior_count (struct inferior
*inf
, void *arg
)
915 mi_on_resume (ptid_t ptid
)
917 struct thread_info
*tp
= NULL
;
919 if (ptid_equal (ptid
, minus_one_ptid
) || ptid_is_pid (ptid
))
920 tp
= inferior_thread ();
922 tp
= find_thread_ptid (ptid
);
924 /* Suppress output while calling an inferior function. */
925 if (tp
->control
.in_infcall
)
928 /* To cater for older frontends, emit ^running, but do it only once
929 per each command. We do it here, since at this point we know
930 that the target was successfully resumed, and in non-async mode,
931 we won't return back to MI interpreter code until the target
932 is done running, so delaying the output of "^running" until then
933 will make it impossible for frontend to know what's going on.
935 In future (MI3), we'll be outputting "^done" here. */
936 if (!running_result_record_printed
&& mi_proceeded
)
938 fprintf_unfiltered (raw_stdout
, "%s^running\n",
939 current_token
? current_token
: "");
942 if (ptid_get_pid (ptid
) == -1)
943 fprintf_unfiltered (raw_stdout
, "*running,thread-id=\"all\"\n");
944 else if (ptid_is_pid (ptid
))
948 /* Backwards compatibility. If there's only one inferior,
949 output "all", otherwise, output each resumed thread
951 iterate_over_inferiors (mi_inferior_count
, &count
);
954 fprintf_unfiltered (raw_stdout
, "*running,thread-id=\"all\"\n");
956 iterate_over_threads (mi_output_running_pid
, &ptid
);
960 struct thread_info
*ti
= find_thread_ptid (ptid
);
963 fprintf_unfiltered (raw_stdout
, "*running,thread-id=\"%d\"\n", ti
->num
);
966 if (!running_result_record_printed
&& mi_proceeded
)
968 running_result_record_printed
= 1;
969 /* This is what gdb used to do historically -- printing prompt even if
970 it cannot actually accept any input. This will be surely removed
971 for MI3, and may be removed even earlier. SYNC_EXECUTION is
972 checked here because we only need to emit a prompt if a
973 synchronous command was issued when the target is async. */
974 if (!target_is_async_p () || sync_execution
)
975 fputs_unfiltered ("(gdb) \n", raw_stdout
);
977 gdb_flush (raw_stdout
);
981 mi_solib_loaded (struct so_list
*solib
)
983 struct mi_interp
*mi
= top_level_interpreter_data ();
984 struct ui_out
*uiout
= interp_ui_out (top_level_interpreter ());
986 target_terminal_ours ();
988 fprintf_unfiltered (mi
->event_channel
, "library-loaded");
990 ui_out_redirect (uiout
, mi
->event_channel
);
992 ui_out_field_string (uiout
, "id", solib
->so_original_name
);
993 ui_out_field_string (uiout
, "target-name", solib
->so_original_name
);
994 ui_out_field_string (uiout
, "host-name", solib
->so_name
);
995 ui_out_field_int (uiout
, "symbols-loaded", solib
->symbols_loaded
);
996 if (!gdbarch_has_global_solist (target_gdbarch ()))
998 ui_out_field_fmt (uiout
, "thread-group", "i%d", current_inferior ()->num
);
1001 ui_out_redirect (uiout
, NULL
);
1003 gdb_flush (mi
->event_channel
);
1007 mi_solib_unloaded (struct so_list
*solib
)
1009 struct mi_interp
*mi
= top_level_interpreter_data ();
1010 struct ui_out
*uiout
= interp_ui_out (top_level_interpreter ());
1012 target_terminal_ours ();
1014 fprintf_unfiltered (mi
->event_channel
, "library-unloaded");
1016 ui_out_redirect (uiout
, mi
->event_channel
);
1018 ui_out_field_string (uiout
, "id", solib
->so_original_name
);
1019 ui_out_field_string (uiout
, "target-name", solib
->so_original_name
);
1020 ui_out_field_string (uiout
, "host-name", solib
->so_name
);
1021 if (!gdbarch_has_global_solist (target_gdbarch ()))
1023 ui_out_field_fmt (uiout
, "thread-group", "i%d", current_inferior ()->num
);
1026 ui_out_redirect (uiout
, NULL
);
1028 gdb_flush (mi
->event_channel
);
1031 /* Emit notification about the command parameter change. */
1034 mi_command_param_changed (const char *param
, const char *value
)
1036 struct mi_interp
*mi
= top_level_interpreter_data ();
1037 struct ui_out
*mi_uiout
= interp_ui_out (top_level_interpreter ());
1039 if (mi_suppress_notification
.cmd_param_changed
)
1042 target_terminal_ours ();
1044 fprintf_unfiltered (mi
->event_channel
,
1045 "cmd-param-changed");
1047 ui_out_redirect (mi_uiout
, mi
->event_channel
);
1049 ui_out_field_string (mi_uiout
, "param", param
);
1050 ui_out_field_string (mi_uiout
, "value", value
);
1052 ui_out_redirect (mi_uiout
, NULL
);
1054 gdb_flush (mi
->event_channel
);
1057 /* Emit notification about the target memory change. */
1060 mi_memory_changed (struct inferior
*inferior
, CORE_ADDR memaddr
,
1061 ssize_t len
, const bfd_byte
*myaddr
)
1063 struct mi_interp
*mi
= top_level_interpreter_data ();
1064 struct ui_out
*mi_uiout
= interp_ui_out (top_level_interpreter ());
1065 struct obj_section
*sec
;
1067 if (mi_suppress_notification
.memory
)
1070 target_terminal_ours ();
1072 fprintf_unfiltered (mi
->event_channel
,
1075 ui_out_redirect (mi_uiout
, mi
->event_channel
);
1077 ui_out_field_fmt (mi_uiout
, "thread-group", "i%d", inferior
->num
);
1078 ui_out_field_core_addr (mi_uiout
, "addr", target_gdbarch (), memaddr
);
1079 ui_out_field_fmt (mi_uiout
, "len", "%s", hex_string (len
));
1081 /* Append 'type=code' into notification if MEMADDR falls in the range of
1082 sections contain code. */
1083 sec
= find_pc_section (memaddr
);
1084 if (sec
!= NULL
&& sec
->objfile
!= NULL
)
1086 flagword flags
= bfd_get_section_flags (sec
->objfile
->obfd
,
1087 sec
->the_bfd_section
);
1089 if (flags
& SEC_CODE
)
1090 ui_out_field_string (mi_uiout
, "type", "code");
1093 ui_out_redirect (mi_uiout
, NULL
);
1095 gdb_flush (mi
->event_channel
);
1099 report_initial_inferior (struct inferior
*inf
, void *closure
)
1101 /* This function is called from mi_intepreter_init, and since
1102 mi_inferior_added assumes that inferior is fully initialized
1103 and top_level_interpreter_data is set, we cannot call
1105 struct mi_interp
*mi
= closure
;
1107 target_terminal_ours ();
1108 fprintf_unfiltered (mi
->event_channel
,
1109 "thread-group-added,id=\"i%d\"",
1111 gdb_flush (mi
->event_channel
);
1115 static struct ui_out
*
1116 mi_ui_out (struct interp
*interp
)
1118 struct mi_interp
*mi
= interp_data (interp
);
1120 return mi
->mi_uiout
;
1123 /* Save the original value of raw_stdout here when logging, so we can
1124 restore correctly when done. */
1126 static struct ui_file
*saved_raw_stdout
;
1128 /* Do MI-specific logging actions; save raw_stdout, and change all
1129 the consoles to use the supplied ui-file(s). */
1132 mi_set_logging (struct interp
*interp
, int start_log
,
1133 struct ui_file
*out
, struct ui_file
*logfile
)
1135 struct mi_interp
*mi
= interp_data (interp
);
1142 /* The tee created already is based on gdb_stdout, which for MI
1143 is a console and so we end up in an infinite loop of console
1144 writing to ui_file writing to console etc. So discard the
1145 existing tee (it hasn't been used yet, and MI won't ever use
1146 it), and create one based on raw_stdout instead. */
1149 ui_file_delete (out
);
1150 out
= tee_file_new (raw_stdout
, 0, logfile
, 0);
1153 saved_raw_stdout
= raw_stdout
;
1158 raw_stdout
= saved_raw_stdout
;
1159 saved_raw_stdout
= NULL
;
1162 mi_console_set_raw (mi
->out
, raw_stdout
);
1163 mi_console_set_raw (mi
->err
, raw_stdout
);
1164 mi_console_set_raw (mi
->log
, raw_stdout
);
1165 mi_console_set_raw (mi
->targ
, raw_stdout
);
1166 mi_console_set_raw (mi
->event_channel
, raw_stdout
);
1171 extern initialize_file_ftype _initialize_mi_interp
; /* -Wmissing-prototypes */
1174 _initialize_mi_interp (void)
1176 static const struct interp_procs procs
=
1178 mi_interpreter_init
, /* init_proc */
1179 mi_interpreter_resume
, /* resume_proc */
1180 mi_interpreter_suspend
, /* suspend_proc */
1181 mi_interpreter_exec
, /* exec_proc */
1182 mi_ui_out
, /* ui_out_proc */
1183 mi_set_logging
, /* set_logging_proc */
1184 mi_command_loop
/* command_loop_proc */
1187 /* The various interpreter levels. */
1188 interp_add (interp_new (INTERP_MI1
, &procs
));
1189 interp_add (interp_new (INTERP_MI2
, &procs
));
1190 interp_add (interp_new (INTERP_MI3
, &procs
));
1191 interp_add (interp_new (INTERP_MI
, &procs
));