1 /* MI Interpreter Definitions and Commands for GDB, the GNU debugger.
3 Copyright (C) 2002-2005, 2007-2012 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/>. */
21 #include "gdb_string.h"
23 #include "event-top.h"
24 #include "event-loop.h"
28 #include "exceptions.h"
32 #include "mi-console.h"
33 #include "mi-common.h"
35 #include "gdbthread.h"
39 /* These are the interpreter setup, etc. functions for the MI
42 static void mi_execute_command_wrapper (char *cmd
);
43 static void mi_execute_command_input_handler (char *cmd
);
44 static void mi_command_loop (int mi_version
);
46 /* These are hooks that we put in place while doing interpreter_exec
47 so we can report interesting things that happened "behind the MI's
48 back" in this command. */
50 static int mi_interp_query_hook (const char *ctlstr
, va_list ap
)
51 ATTRIBUTE_PRINTF (1, 0);
53 static void mi3_command_loop (void);
54 static void mi2_command_loop (void);
55 static void mi1_command_loop (void);
57 static void mi_insert_notify_hooks (void);
58 static void mi_remove_notify_hooks (void);
59 static void mi_on_normal_stop (struct bpstats
*bs
, int print_frame
);
61 static void mi_new_thread (struct thread_info
*t
);
62 static void mi_thread_exit (struct thread_info
*t
, int silent
);
63 static void mi_inferior_added (struct inferior
*inf
);
64 static void mi_inferior_appeared (struct inferior
*inf
);
65 static void mi_inferior_exit (struct inferior
*inf
);
66 static void mi_inferior_removed (struct inferior
*inf
);
67 static void mi_on_resume (ptid_t ptid
);
68 static void mi_solib_loaded (struct so_list
*solib
);
69 static void mi_solib_unloaded (struct so_list
*solib
);
70 static void mi_about_to_proceed (void);
71 static void mi_breakpoint_created (struct breakpoint
*b
);
72 static void mi_breakpoint_deleted (struct breakpoint
*b
);
73 static void mi_breakpoint_modified (struct breakpoint
*b
);
75 static int report_initial_inferior (struct inferior
*inf
, void *closure
);
78 mi_interpreter_init (struct interp
*interp
, int top_level
)
80 struct mi_interp
*mi
= XMALLOC (struct mi_interp
);
84 /* Assign the output channel created at startup to its own global,
85 so that we can create a console channel that encapsulates and
86 prefixes all gdb_output-type bits coming from the rest of the
89 raw_stdout
= gdb_stdout
;
91 /* Create MI console channels, each with a different prefix so they
92 can be distinguished. */
93 mi
->out
= mi_console_file_new (raw_stdout
, "~", '"');
94 mi
->err
= mi_console_file_new (raw_stdout
, "&", '"');
96 mi
->targ
= mi_console_file_new (raw_stdout
, "@", '"');
97 mi
->event_channel
= mi_console_file_new (raw_stdout
, "=", 0);
99 name
= interp_name (interp
);
100 /* INTERP_MI selects the most recent released version. "mi2" was
101 released as part of GDB 6.0. */
102 if (strcmp (name
, INTERP_MI
) == 0)
104 else if (strcmp (name
, INTERP_MI1
) == 0)
106 else if (strcmp (name
, INTERP_MI2
) == 0)
108 else if (strcmp (name
, INTERP_MI3
) == 0)
111 gdb_assert_not_reached ("unhandled MI version");
113 mi
->uiout
= mi_out_new (mi_version
);
117 observer_attach_new_thread (mi_new_thread
);
118 observer_attach_thread_exit (mi_thread_exit
);
119 observer_attach_inferior_added (mi_inferior_added
);
120 observer_attach_inferior_appeared (mi_inferior_appeared
);
121 observer_attach_inferior_exit (mi_inferior_exit
);
122 observer_attach_inferior_removed (mi_inferior_removed
);
123 observer_attach_normal_stop (mi_on_normal_stop
);
124 observer_attach_target_resumed (mi_on_resume
);
125 observer_attach_solib_loaded (mi_solib_loaded
);
126 observer_attach_solib_unloaded (mi_solib_unloaded
);
127 observer_attach_about_to_proceed (mi_about_to_proceed
);
128 observer_attach_breakpoint_created (mi_breakpoint_created
);
129 observer_attach_breakpoint_deleted (mi_breakpoint_deleted
);
130 observer_attach_breakpoint_modified (mi_breakpoint_modified
);
132 /* The initial inferior is created before this function is
133 called, so we need to report it explicitly. Use iteration in
134 case future version of GDB creates more than one inferior
136 iterate_over_inferiors (report_initial_inferior
, mi
);
143 mi_interpreter_resume (void *data
)
145 struct mi_interp
*mi
= data
;
147 /* As per hack note in mi_interpreter_init, swap in the output
149 gdb_setup_readline ();
151 /* These overwrite some of the initialization done in
152 _intialize_event_loop. */
153 call_readline
= gdb_readline2
;
154 input_handler
= mi_execute_command_input_handler
;
155 add_file_handler (input_fd
, stdin_event_handler
, 0);
156 async_command_editing_p
= 0;
157 /* FIXME: This is a total hack for now. PB's use of the MI
158 implicitly relies on a bug in the async support which allows
159 asynchronous commands to leak through the commmand loop. The bug
160 involves (but is not limited to) the fact that sync_execution was
161 erroneously initialized to 0. Duplicate by initializing it thus
165 gdb_stdout
= mi
->out
;
166 /* Route error and log output through the MI. */
167 gdb_stderr
= mi
->err
;
168 gdb_stdlog
= mi
->log
;
169 /* Route target output through the MI. */
170 gdb_stdtarg
= mi
->targ
;
171 /* Route target error through the MI as well. */
172 gdb_stdtargerr
= mi
->targ
;
174 /* Replace all the hooks that we know about. There really needs to
175 be a better way of doing this... */
176 clear_interpreter_hooks ();
178 deprecated_show_load_progress
= mi_load_progress
;
180 /* If we're _the_ interpreter, take control. */
181 if (current_interp_named_p (INTERP_MI1
))
182 deprecated_command_loop_hook
= mi1_command_loop
;
183 else if (current_interp_named_p (INTERP_MI2
))
184 deprecated_command_loop_hook
= mi2_command_loop
;
185 else if (current_interp_named_p (INTERP_MI3
))
186 deprecated_command_loop_hook
= mi3_command_loop
;
188 deprecated_command_loop_hook
= mi2_command_loop
;
194 mi_interpreter_suspend (void *data
)
196 gdb_disable_readline ();
200 static struct gdb_exception
201 mi_interpreter_exec (void *data
, const char *command
)
203 char *tmp
= alloca (strlen (command
) + 1);
205 strcpy (tmp
, command
);
206 mi_execute_command_wrapper (tmp
);
207 return exception_none
;
210 /* Never display the default GDB prompt in MI case. */
213 mi_interpreter_prompt_p (void *data
)
219 mi_cmd_interpreter_exec (char *command
, char **argv
, int argc
)
221 struct interp
*interp_to_use
;
223 char *mi_error_message
= NULL
;
224 struct cleanup
*old_chain
;
227 error (_("-interpreter-exec: "
228 "Usage: -interpreter-exec interp command"));
230 interp_to_use
= interp_lookup (argv
[0]);
231 if (interp_to_use
== NULL
)
232 error (_("-interpreter-exec: could not find interpreter \"%s\""),
235 if (!interp_exec_p (interp_to_use
))
236 error (_("-interpreter-exec: interpreter \"%s\" "
237 "does not support command execution"),
240 /* Insert the MI out hooks, making sure to also call the
241 interpreter's hooks if it has any. */
242 /* KRS: We shouldn't need this... Events should be installed and
243 they should just ALWAYS fire something out down the MI
245 mi_insert_notify_hooks ();
247 /* Now run the code. */
249 old_chain
= make_cleanup (null_cleanup
, 0);
250 for (i
= 1; i
< argc
; i
++)
252 struct gdb_exception e
= interp_exec (interp_to_use
, argv
[i
]);
256 mi_error_message
= xstrdup (e
.message
);
257 make_cleanup (xfree
, mi_error_message
);
262 mi_remove_notify_hooks ();
264 if (mi_error_message
!= NULL
)
265 error ("%s", mi_error_message
);
266 do_cleanups (old_chain
);
269 /* This inserts a number of hooks that are meant to produce
270 async-notify ("=") MI messages while running commands in another
271 interpreter using mi_interpreter_exec. The canonical use for this
272 is to allow access to the gdb CLI interpreter from within the MI,
273 while still producing MI style output when actions in the CLI
274 command change GDB's state. */
277 mi_insert_notify_hooks (void)
279 deprecated_query_hook
= mi_interp_query_hook
;
283 mi_remove_notify_hooks (void)
285 deprecated_query_hook
= NULL
;
289 mi_interp_query_hook (const char *ctlstr
, va_list ap
)
295 mi_execute_command_wrapper (char *cmd
)
297 mi_execute_command (cmd
, stdin
== instream
);
300 /* mi_execute_command_wrapper wrapper suitable for INPUT_HANDLER. */
303 mi_execute_command_input_handler (char *cmd
)
305 mi_execute_command_wrapper (cmd
);
307 fputs_unfiltered ("(gdb) \n", raw_stdout
);
308 gdb_flush (raw_stdout
);
312 mi1_command_loop (void)
318 mi2_command_loop (void)
324 mi3_command_loop (void)
330 mi_command_loop (int mi_version
)
332 /* Turn off 8 bit strings in quoted output. Any character with the
333 high bit set is printed using C's octal format. */
334 sevenbit_strings
= 1;
336 /* Tell the world that we're alive. */
337 fputs_unfiltered ("(gdb) \n", raw_stdout
);
338 gdb_flush (raw_stdout
);
344 mi_new_thread (struct thread_info
*t
)
346 struct mi_interp
*mi
= top_level_interpreter_data ();
347 struct inferior
*inf
= find_inferior_pid (ptid_get_pid (t
->ptid
));
351 fprintf_unfiltered (mi
->event_channel
,
352 "thread-created,id=\"%d\",group-id=\"i%d\"",
354 gdb_flush (mi
->event_channel
);
358 mi_thread_exit (struct thread_info
*t
, int silent
)
360 struct mi_interp
*mi
;
361 struct inferior
*inf
;
366 inf
= find_inferior_pid (ptid_get_pid (t
->ptid
));
368 mi
= top_level_interpreter_data ();
369 target_terminal_ours ();
370 fprintf_unfiltered (mi
->event_channel
,
371 "thread-exited,id=\"%d\",group-id=\"i%d\"",
373 gdb_flush (mi
->event_channel
);
377 mi_inferior_added (struct inferior
*inf
)
379 struct mi_interp
*mi
= top_level_interpreter_data ();
381 target_terminal_ours ();
382 fprintf_unfiltered (mi
->event_channel
,
383 "thread-group-added,id=\"i%d\"",
385 gdb_flush (mi
->event_channel
);
389 mi_inferior_appeared (struct inferior
*inf
)
391 struct mi_interp
*mi
= top_level_interpreter_data ();
393 target_terminal_ours ();
394 fprintf_unfiltered (mi
->event_channel
,
395 "thread-group-started,id=\"i%d\",pid=\"%d\"",
397 gdb_flush (mi
->event_channel
);
401 mi_inferior_exit (struct inferior
*inf
)
403 struct mi_interp
*mi
= top_level_interpreter_data ();
405 target_terminal_ours ();
406 if (inf
->has_exit_code
)
407 fprintf_unfiltered (mi
->event_channel
,
408 "thread-group-exited,id=\"i%d\",exit-code=\"%s\"",
409 inf
->num
, int_string (inf
->exit_code
, 8, 0, 0, 1));
411 fprintf_unfiltered (mi
->event_channel
,
412 "thread-group-exited,id=\"i%d\"", inf
->num
);
414 gdb_flush (mi
->event_channel
);
418 mi_inferior_removed (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-removed,id=\"i%d\"",
426 gdb_flush (mi
->event_channel
);
430 mi_on_normal_stop (struct bpstats
*bs
, int print_frame
)
432 /* Since this can be called when CLI command is executing,
433 using cli interpreter, be sure to use MI uiout for output,
434 not the current one. */
435 struct ui_out
*mi_uiout
= interp_ui_out (top_level_interpreter ());
441 if (current_uiout
!= mi_uiout
)
443 /* The normal_stop function has printed frame information
444 into CLI uiout, or some other non-MI uiout. There's no
445 way we can extract proper fields from random uiout
446 object, so we print the frame again. In practice, this
447 can only happen when running a CLI command in MI. */
448 struct ui_out
*saved_uiout
= current_uiout
;
449 struct target_waitstatus last
;
452 current_uiout
= mi_uiout
;
454 get_last_target_status (&last_ptid
, &last
);
455 bpstat_print (bs
, last
.kind
);
457 print_stack_frame (get_selected_frame (NULL
), 0, SRC_AND_LOC
);
458 current_uiout
= saved_uiout
;
461 ui_out_field_int (mi_uiout
, "thread-id",
462 pid_to_thread_id (inferior_ptid
));
465 struct cleanup
*back_to
= make_cleanup_ui_out_list_begin_end
466 (mi_uiout
, "stopped-threads");
468 ui_out_field_int (mi_uiout
, NULL
,
469 pid_to_thread_id (inferior_ptid
));
470 do_cleanups (back_to
);
473 ui_out_field_string (mi_uiout
, "stopped-threads", "all");
475 core
= target_core_of_thread (inferior_ptid
);
477 ui_out_field_int (mi_uiout
, "core", core
);
480 fputs_unfiltered ("*stopped", raw_stdout
);
481 mi_out_put (mi_uiout
, raw_stdout
);
482 mi_out_rewind (mi_uiout
);
483 mi_print_timing_maybe ();
484 fputs_unfiltered ("\n", raw_stdout
);
485 gdb_flush (raw_stdout
);
489 mi_about_to_proceed (void)
491 /* Suppress output while calling an inferior function. */
493 if (!ptid_equal (inferior_ptid
, null_ptid
))
495 struct thread_info
*tp
= inferior_thread ();
497 if (tp
->control
.in_infcall
)
504 /* When non-zero, no MI notifications will be emitted in
505 response to breakpoint change observers. */
507 int mi_suppress_breakpoint_notifications
= 0;
509 /* Emit notification about a created breakpoint. */
512 mi_breakpoint_created (struct breakpoint
*b
)
514 struct mi_interp
*mi
= top_level_interpreter_data ();
515 struct ui_out
*mi_uiout
= interp_ui_out (top_level_interpreter ());
516 volatile struct gdb_exception e
;
518 if (mi_suppress_breakpoint_notifications
)
524 target_terminal_ours ();
525 fprintf_unfiltered (mi
->event_channel
,
526 "breakpoint-created");
527 /* We want the output from gdb_breakpoint_query to go to
528 mi->event_channel. One approach would be to just call
529 gdb_breakpoint_query, and then use mi_out_put to send the current
530 content of mi_outout into mi->event_channel. However, that will
531 break if anything is output to mi_uiout prior to calling the
532 breakpoint_created notifications. So, we use
534 ui_out_redirect (mi_uiout
, mi
->event_channel
);
535 TRY_CATCH (e
, RETURN_MASK_ERROR
)
536 gdb_breakpoint_query (mi_uiout
, b
->number
, NULL
);
537 ui_out_redirect (mi_uiout
, NULL
);
539 gdb_flush (mi
->event_channel
);
542 /* Emit notification about deleted breakpoint. */
545 mi_breakpoint_deleted (struct breakpoint
*b
)
547 struct mi_interp
*mi
= top_level_interpreter_data ();
549 if (mi_suppress_breakpoint_notifications
)
555 target_terminal_ours ();
557 fprintf_unfiltered (mi
->event_channel
, "breakpoint-deleted,id=\"%d\"",
560 gdb_flush (mi
->event_channel
);
563 /* Emit notification about modified breakpoint. */
566 mi_breakpoint_modified (struct breakpoint
*b
)
568 struct mi_interp
*mi
= top_level_interpreter_data ();
569 struct ui_out
*mi_uiout
= interp_ui_out (top_level_interpreter ());
570 volatile struct gdb_exception e
;
572 if (mi_suppress_breakpoint_notifications
)
578 target_terminal_ours ();
579 fprintf_unfiltered (mi
->event_channel
,
580 "breakpoint-modified");
581 /* We want the output from gdb_breakpoint_query to go to
582 mi->event_channel. One approach would be to just call
583 gdb_breakpoint_query, and then use mi_out_put to send the current
584 content of mi_outout into mi->event_channel. However, that will
585 break if anything is output to mi_uiout prior to calling the
586 breakpoint_created notifications. So, we use
588 ui_out_redirect (mi_uiout
, mi
->event_channel
);
589 TRY_CATCH (e
, RETURN_MASK_ERROR
)
590 gdb_breakpoint_query (mi_uiout
, b
->number
, NULL
);
591 ui_out_redirect (mi_uiout
, NULL
);
593 gdb_flush (mi
->event_channel
);
597 mi_output_running_pid (struct thread_info
*info
, void *arg
)
601 if (ptid_get_pid (*ptid
) == ptid_get_pid (info
->ptid
))
602 fprintf_unfiltered (raw_stdout
,
603 "*running,thread-id=\"%d\"\n",
610 mi_inferior_count (struct inferior
*inf
, void *arg
)
622 mi_on_resume (ptid_t ptid
)
624 struct thread_info
*tp
= NULL
;
626 if (ptid_equal (ptid
, minus_one_ptid
) || ptid_is_pid (ptid
))
627 tp
= inferior_thread ();
629 tp
= find_thread_ptid (ptid
);
631 /* Suppress output while calling an inferior function. */
632 if (tp
->control
.in_infcall
)
635 /* To cater for older frontends, emit ^running, but do it only once
636 per each command. We do it here, since at this point we know
637 that the target was successfully resumed, and in non-async mode,
638 we won't return back to MI interpreter code until the target
639 is done running, so delaying the output of "^running" until then
640 will make it impossible for frontend to know what's going on.
642 In future (MI3), we'll be outputting "^done" here. */
643 if (!running_result_record_printed
&& mi_proceeded
)
645 fprintf_unfiltered (raw_stdout
, "%s^running\n",
646 current_token
? current_token
: "");
649 if (PIDGET (ptid
) == -1)
650 fprintf_unfiltered (raw_stdout
, "*running,thread-id=\"all\"\n");
651 else if (ptid_is_pid (ptid
))
655 /* Backwards compatibility. If there's only one inferior,
656 output "all", otherwise, output each resumed thread
658 iterate_over_inferiors (mi_inferior_count
, &count
);
661 fprintf_unfiltered (raw_stdout
, "*running,thread-id=\"all\"\n");
663 iterate_over_threads (mi_output_running_pid
, &ptid
);
667 struct thread_info
*ti
= find_thread_ptid (ptid
);
670 fprintf_unfiltered (raw_stdout
, "*running,thread-id=\"%d\"\n", ti
->num
);
673 if (!running_result_record_printed
&& mi_proceeded
)
675 running_result_record_printed
= 1;
676 /* This is what gdb used to do historically -- printing prompt even if
677 it cannot actually accept any input. This will be surely removed
678 for MI3, and may be removed even earler. */
679 /* FIXME: review the use of target_is_async_p here -- is that
681 if (!target_is_async_p ())
682 fputs_unfiltered ("(gdb) \n", raw_stdout
);
684 gdb_flush (raw_stdout
);
688 mi_solib_loaded (struct so_list
*solib
)
690 struct mi_interp
*mi
= top_level_interpreter_data ();
692 target_terminal_ours ();
693 if (gdbarch_has_global_solist (target_gdbarch
))
694 fprintf_unfiltered (mi
->event_channel
,
695 "library-loaded,id=\"%s\",target-name=\"%s\","
696 "host-name=\"%s\",symbols-loaded=\"%d\"",
697 solib
->so_original_name
, solib
->so_original_name
,
698 solib
->so_name
, solib
->symbols_loaded
);
700 fprintf_unfiltered (mi
->event_channel
,
701 "library-loaded,id=\"%s\",target-name=\"%s\","
702 "host-name=\"%s\",symbols-loaded=\"%d\","
703 "thread-group=\"i%d\"",
704 solib
->so_original_name
, solib
->so_original_name
,
705 solib
->so_name
, solib
->symbols_loaded
,
706 current_inferior ()->num
);
708 gdb_flush (mi
->event_channel
);
712 mi_solib_unloaded (struct so_list
*solib
)
714 struct mi_interp
*mi
= top_level_interpreter_data ();
716 target_terminal_ours ();
717 if (gdbarch_has_global_solist (target_gdbarch
))
718 fprintf_unfiltered (mi
->event_channel
,
719 "library-unloaded,id=\"%s\",target-name=\"%s\","
721 solib
->so_original_name
, solib
->so_original_name
,
724 fprintf_unfiltered (mi
->event_channel
,
725 "library-unloaded,id=\"%s\",target-name=\"%s\","
726 "host-name=\"%s\",thread-group=\"i%d\"",
727 solib
->so_original_name
, solib
->so_original_name
,
728 solib
->so_name
, current_inferior ()->num
);
730 gdb_flush (mi
->event_channel
);
734 report_initial_inferior (struct inferior
*inf
, void *closure
)
736 /* This function is called from mi_intepreter_init, and since
737 mi_inferior_added assumes that inferior is fully initialized
738 and top_level_interpreter_data is set, we cannot call
740 struct mi_interp
*mi
= closure
;
742 target_terminal_ours ();
743 fprintf_unfiltered (mi
->event_channel
,
744 "thread-group-added,id=\"i%d\"",
746 gdb_flush (mi
->event_channel
);
750 static struct ui_out
*
751 mi_ui_out (struct interp
*interp
)
753 struct mi_interp
*mi
= interp_data (interp
);
758 /* Save the original value of raw_stdout here when logging, so we can
759 restore correctly when done. */
761 static struct ui_file
*saved_raw_stdout
;
763 /* Do MI-specific logging actions; save raw_stdout, and change all
764 the consoles to use the supplied ui-file(s). */
767 mi_set_logging (struct interp
*interp
, int start_log
,
768 struct ui_file
*out
, struct ui_file
*logfile
)
770 struct mi_interp
*mi
= interp_data (interp
);
777 /* The tee created already is based on gdb_stdout, which for MI
778 is a console and so we end up in an infinite loop of console
779 writing to ui_file writing to console etc. So discard the
780 existing tee (it hasn't been used yet, and MI won't ever use
781 it), and create one based on raw_stdout instead. */
784 ui_file_delete (out
);
785 out
= tee_file_new (raw_stdout
, 0, logfile
, 0);
788 saved_raw_stdout
= raw_stdout
;
793 raw_stdout
= saved_raw_stdout
;
794 saved_raw_stdout
= NULL
;
797 mi_console_set_raw (mi
->out
, raw_stdout
);
798 mi_console_set_raw (mi
->err
, raw_stdout
);
799 mi_console_set_raw (mi
->log
, raw_stdout
);
800 mi_console_set_raw (mi
->targ
, raw_stdout
);
801 mi_console_set_raw (mi
->event_channel
, raw_stdout
);
806 extern initialize_file_ftype _initialize_mi_interp
; /* -Wmissing-prototypes */
809 _initialize_mi_interp (void)
811 static const struct interp_procs procs
=
813 mi_interpreter_init
, /* init_proc */
814 mi_interpreter_resume
, /* resume_proc */
815 mi_interpreter_suspend
, /* suspend_proc */
816 mi_interpreter_exec
, /* exec_proc */
817 mi_interpreter_prompt_p
, /* prompt_proc_p */
818 mi_ui_out
, /* ui_out_proc */
819 mi_set_logging
/* set_logging_proc */
822 /* The various interpreter levels. */
823 interp_add (interp_new (INTERP_MI1
, &procs
));
824 interp_add (interp_new (INTERP_MI2
, &procs
));
825 interp_add (interp_new (INTERP_MI3
, &procs
));
826 interp_add (interp_new (INTERP_MI
, &procs
));