1 /* MI Interpreter Definitions and Commands for GDB, the GNU debugger.
3 Copyright (C) 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010, 2011
4 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 #include "gdb_string.h"
24 #include "event-top.h"
25 #include "event-loop.h"
29 #include "exceptions.h"
33 #include "mi-console.h"
34 #include "mi-common.h"
36 #include "gdbthread.h"
40 /* These are the interpreter setup, etc. functions for the MI interpreter */
41 static void mi_execute_command_wrapper (char *cmd);
42 static void mi_command_loop (int mi_version);
44 /* These are hooks that we put in place while doing interpreter_exec
45 so we can report interesting things that happened "behind the mi's
46 back" in this command */
47 static int mi_interp_query_hook (const char *ctlstr, va_list ap)
48 ATTRIBUTE_PRINTF (1, 0);
50 static void mi3_command_loop (void);
51 static void mi2_command_loop (void);
52 static void mi1_command_loop (void);
54 static void mi_insert_notify_hooks (void);
55 static void mi_remove_notify_hooks (void);
56 static void mi_on_normal_stop (struct bpstats *bs, int print_frame);
58 static void mi_new_thread (struct thread_info *t);
59 static void mi_thread_exit (struct thread_info *t, int silent);
60 static void mi_inferior_added (struct inferior *inf);
61 static void mi_inferior_appeared (struct inferior *inf);
62 static void mi_inferior_exit (struct inferior *inf);
63 static void mi_inferior_removed (struct inferior *inf);
64 static void mi_on_resume (ptid_t ptid);
65 static void mi_solib_loaded (struct so_list *solib);
66 static void mi_solib_unloaded (struct so_list *solib);
67 static void mi_about_to_proceed (void);
68 static void mi_breakpoint_created (struct breakpoint *b);
69 static void mi_breakpoint_deleted (struct breakpoint *b);
70 static void mi_breakpoint_modified (struct breakpoint *b);
72 static int report_initial_inferior (struct inferior *inf, void *closure);
75 mi_interpreter_init (struct interp *interp, int top_level)
77 struct mi_interp *mi = XMALLOC (struct mi_interp);
81 /* HACK: We need to force stdout/stderr to point at the console. This avoids
82 any potential side effects caused by legacy code that is still
83 using the TUI / fputs_unfiltered_hook. So we set up output channels for
84 this now, and swap them in when we are run. */
86 raw_stdout = stdio_fileopen (stdout);
88 /* Create MI channels */
89 mi->out = mi_console_file_new (raw_stdout, "~", '"');
90 mi->err = mi_console_file_new (raw_stdout, "&", '"');
92 mi->targ = mi_console_file_new (raw_stdout, "@", '"');
93 mi->event_channel = mi_console_file_new (raw_stdout, "=", 0);
95 name = interp_name (interp);
96 /* INTERP_MI selects the most recent released version. "mi2" was
97 released as part of GDB 6.0. */
98 if (strcmp (name, INTERP_MI) == 0)
100 else if (strcmp (name, INTERP_MI1) == 0)
102 else if (strcmp (name, INTERP_MI2) == 0)
104 else if (strcmp (name, INTERP_MI3) == 0)
107 gdb_assert_not_reached ("unhandled MI version");
109 mi->uiout = mi_out_new (mi_version);
113 observer_attach_new_thread (mi_new_thread);
114 observer_attach_thread_exit (mi_thread_exit);
115 observer_attach_inferior_added (mi_inferior_added);
116 observer_attach_inferior_appeared (mi_inferior_appeared);
117 observer_attach_inferior_exit (mi_inferior_exit);
118 observer_attach_inferior_removed (mi_inferior_removed);
119 observer_attach_normal_stop (mi_on_normal_stop);
120 observer_attach_target_resumed (mi_on_resume);
121 observer_attach_solib_loaded (mi_solib_loaded);
122 observer_attach_solib_unloaded (mi_solib_unloaded);
123 observer_attach_about_to_proceed (mi_about_to_proceed);
124 observer_attach_breakpoint_created (mi_breakpoint_created);
125 observer_attach_breakpoint_deleted (mi_breakpoint_deleted);
126 observer_attach_breakpoint_modified (mi_breakpoint_modified);
128 /* The initial inferior is created before this function is called, so we
129 need to report it explicitly. Use iteration in case future version
130 of GDB creates more than one inferior up-front. */
131 iterate_over_inferiors (report_initial_inferior, mi);
138 mi_interpreter_resume (void *data)
140 struct mi_interp *mi = data;
142 /* As per hack note in mi_interpreter_init, swap in the output channels... */
143 gdb_setup_readline ();
145 /* These overwrite some of the initialization done in
146 _intialize_event_loop. */
147 call_readline = gdb_readline2;
148 input_handler = mi_execute_command_wrapper;
149 add_file_handler (input_fd, stdin_event_handler, 0);
150 async_command_editing_p = 0;
151 /* FIXME: This is a total hack for now. PB's use of the MI
152 implicitly relies on a bug in the async support which allows
153 asynchronous commands to leak through the commmand loop. The bug
154 involves (but is not limited to) the fact that sync_execution was
155 erroneously initialized to 0. Duplicate by initializing it thus
159 gdb_stdout = mi->out;
160 /* Route error and log output through the MI */
161 gdb_stderr = mi->err;
162 gdb_stdlog = mi->log;
163 /* Route target output through the MI. */
164 gdb_stdtarg = mi->targ;
165 /* Route target error through the MI as well. */
166 gdb_stdtargerr = mi->targ;
168 /* Replace all the hooks that we know about. There really needs to
169 be a better way of doing this... */
170 clear_interpreter_hooks ();
172 deprecated_show_load_progress = mi_load_progress;
174 /* If we're _the_ interpreter, take control. */
175 if (current_interp_named_p (INTERP_MI1))
176 deprecated_command_loop_hook = mi1_command_loop;
177 else if (current_interp_named_p (INTERP_MI2))
178 deprecated_command_loop_hook = mi2_command_loop;
179 else if (current_interp_named_p (INTERP_MI3))
180 deprecated_command_loop_hook = mi3_command_loop;
182 deprecated_command_loop_hook = mi2_command_loop;
188 mi_interpreter_suspend (void *data)
190 gdb_disable_readline ();
194 static struct gdb_exception
195 mi_interpreter_exec (void *data, const char *command)
197 char *tmp = alloca (strlen (command) + 1);
199 strcpy (tmp, command);
200 mi_execute_command_wrapper (tmp);
201 return exception_none;
204 /* Never display the default gdb prompt in mi case. */
206 mi_interpreter_prompt_p (void *data)
212 mi_cmd_interpreter_exec (char *command, char **argv, int argc)
214 struct interp *interp_to_use;
216 char *mi_error_message = NULL;
217 struct cleanup *old_chain;
220 error (_("-interpreter-exec: "
221 "Usage: -interpreter-exec interp command"));
223 interp_to_use = interp_lookup (argv[0]);
224 if (interp_to_use == NULL)
225 error (_("-interpreter-exec: could not find interpreter \"%s\""),
228 if (!interp_exec_p (interp_to_use))
229 error (_("-interpreter-exec: interpreter \"%s\" "
230 "does not support command execution"),
233 /* Insert the MI out hooks, making sure to also call the interpreter's hooks
235 /* KRS: We shouldn't need this... Events should be installed and they should
236 just ALWAYS fire something out down the MI channel... */
237 mi_insert_notify_hooks ();
239 /* Now run the code... */
241 old_chain = make_cleanup (null_cleanup, 0);
242 for (i = 1; i < argc; i++)
244 struct gdb_exception e = interp_exec (interp_to_use, argv[i]);
248 mi_error_message = xstrdup (e.message);
249 make_cleanup (xfree, mi_error_message);
254 mi_remove_notify_hooks ();
256 if (mi_error_message != NULL)
257 error ("%s", mi_error_message);
258 do_cleanups (old_chain);
262 * mi_insert_notify_hooks - This inserts a number of hooks that are
263 * meant to produce async-notify ("=") MI messages while running
264 * commands in another interpreter using mi_interpreter_exec. The
265 * canonical use for this is to allow access to the gdb CLI
266 * interpreter from within the MI, while still producing MI style
267 * output when actions in the CLI command change gdb's state.
271 mi_insert_notify_hooks (void)
273 deprecated_query_hook = mi_interp_query_hook;
277 mi_remove_notify_hooks (void)
279 deprecated_query_hook = NULL;
283 mi_interp_query_hook (const char *ctlstr, va_list ap)
289 mi_execute_command_wrapper (char *cmd)
291 mi_execute_command (cmd, stdin == instream);
295 mi1_command_loop (void)
301 mi2_command_loop (void)
307 mi3_command_loop (void)
313 mi_command_loop (int mi_version)
315 /* Turn off 8 bit strings in quoted output. Any character with the
316 high bit set is printed using C's octal format. */
317 sevenbit_strings = 1;
318 /* Tell the world that we're alive */
319 fputs_unfiltered ("(gdb) \n", raw_stdout);
320 gdb_flush (raw_stdout);
325 mi_new_thread (struct thread_info *t)
327 struct mi_interp *mi = top_level_interpreter_data ();
328 struct inferior *inf = find_inferior_pid (ptid_get_pid (t->ptid));
332 fprintf_unfiltered (mi->event_channel,
333 "thread-created,id=\"%d\",group-id=\"i%d\"",
335 gdb_flush (mi->event_channel);
339 mi_thread_exit (struct thread_info *t, int silent)
341 struct mi_interp *mi;
342 struct inferior *inf;
347 inf = find_inferior_pid (ptid_get_pid (t->ptid));
349 mi = top_level_interpreter_data ();
350 target_terminal_ours ();
351 fprintf_unfiltered (mi->event_channel,
352 "thread-exited,id=\"%d\",group-id=\"i%d\"",
354 gdb_flush (mi->event_channel);
358 mi_inferior_added (struct inferior *inf)
360 struct mi_interp *mi = top_level_interpreter_data ();
362 target_terminal_ours ();
363 fprintf_unfiltered (mi->event_channel,
364 "thread-group-added,id=\"i%d\"",
366 gdb_flush (mi->event_channel);
370 mi_inferior_appeared (struct inferior *inf)
372 struct mi_interp *mi = top_level_interpreter_data ();
374 target_terminal_ours ();
375 fprintf_unfiltered (mi->event_channel,
376 "thread-group-started,id=\"i%d\",pid=\"%d\"",
378 gdb_flush (mi->event_channel);
382 mi_inferior_exit (struct inferior *inf)
384 struct mi_interp *mi = top_level_interpreter_data ();
386 target_terminal_ours ();
387 if (inf->has_exit_code)
388 fprintf_unfiltered (mi->event_channel,
389 "thread-group-exited,id=\"i%d\",exit-code=\"%s\"",
390 inf->num, int_string (inf->exit_code, 8, 0, 0, 1));
392 fprintf_unfiltered (mi->event_channel,
393 "thread-group-exited,id=\"i%d\"", inf->num);
395 gdb_flush (mi->event_channel);
399 mi_inferior_removed (struct inferior *inf)
401 struct mi_interp *mi = top_level_interpreter_data ();
403 target_terminal_ours ();
404 fprintf_unfiltered (mi->event_channel,
405 "thread-group-removed,id=\"i%d\"",
407 gdb_flush (mi->event_channel);
411 mi_on_normal_stop (struct bpstats *bs, int print_frame)
413 /* Since this can be called when CLI command is executing,
414 using cli interpreter, be sure to use MI uiout for output,
415 not the current one. */
416 struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
422 if (current_uiout != mi_uiout)
424 /* The normal_stop function has printed frame information into
425 CLI uiout, or some other non-MI uiout. There's no way we
426 can extract proper fields from random uiout object, so we print
427 the frame again. In practice, this can only happen when running
428 a CLI command in MI. */
429 struct ui_out *saved_uiout = current_uiout;
431 current_uiout = mi_uiout;
433 print_stack_frame (get_selected_frame (NULL), 0, SRC_AND_LOC);
434 current_uiout = saved_uiout;
437 ui_out_field_int (mi_uiout, "thread-id",
438 pid_to_thread_id (inferior_ptid));
441 struct cleanup *back_to = make_cleanup_ui_out_list_begin_end
442 (mi_uiout, "stopped-threads");
444 ui_out_field_int (mi_uiout, NULL,
445 pid_to_thread_id (inferior_ptid));
446 do_cleanups (back_to);
449 ui_out_field_string (mi_uiout, "stopped-threads", "all");
451 core = target_core_of_thread (inferior_ptid);
453 ui_out_field_int (mi_uiout, "core", core);
456 fputs_unfiltered ("*stopped", raw_stdout);
457 mi_out_put (mi_uiout, raw_stdout);
458 mi_out_rewind (mi_uiout);
459 mi_print_timing_maybe ();
460 fputs_unfiltered ("\n", raw_stdout);
461 gdb_flush (raw_stdout);
465 mi_about_to_proceed (void)
467 /* Suppress output while calling an inferior function. */
469 if (!ptid_equal (inferior_ptid, null_ptid))
471 struct thread_info *tp = inferior_thread ();
473 if (tp->control.in_infcall)
480 /* When non-zero, no MI notifications will be emitted in
481 response to breakpoint change observers. */
482 int mi_suppress_breakpoint_notifications = 0;
484 /* Emit notification about a created breakpoint. */
486 mi_breakpoint_created (struct breakpoint *b)
488 struct mi_interp *mi = top_level_interpreter_data ();
489 struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
490 struct gdb_exception e;
492 if (mi_suppress_breakpoint_notifications)
498 target_terminal_ours ();
499 fprintf_unfiltered (mi->event_channel,
500 "breakpoint-created");
501 /* We want the output from gdb_breakpoint_query to go to
502 mi->event_channel. One approach would be to just
503 call gdb_breakpoint_query, and then use mi_out_put to
504 send the current content of mi_outout into mi->event_channel.
505 However, that will break if anything is output to mi_uiout
506 prior the calling the breakpoint_created notifications.
507 So, we use ui_out_redirect. */
508 ui_out_redirect (mi_uiout, mi->event_channel);
509 TRY_CATCH (e, RETURN_MASK_ERROR)
510 gdb_breakpoint_query (mi_uiout, b->number, NULL);
511 ui_out_redirect (mi_uiout, NULL);
513 gdb_flush (mi->event_channel);
516 /* Emit notification about deleted breakpoint. */
518 mi_breakpoint_deleted (struct breakpoint *b)
520 struct mi_interp *mi = top_level_interpreter_data ();
522 if (mi_suppress_breakpoint_notifications)
528 target_terminal_ours ();
530 fprintf_unfiltered (mi->event_channel, "breakpoint-deleted,id=\"%d\"",
533 gdb_flush (mi->event_channel);
536 /* Emit notification about modified breakpoint. */
538 mi_breakpoint_modified (struct breakpoint *b)
540 struct mi_interp *mi = top_level_interpreter_data ();
541 struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
542 struct gdb_exception e;
544 if (mi_suppress_breakpoint_notifications)
550 target_terminal_ours ();
551 fprintf_unfiltered (mi->event_channel,
552 "breakpoint-modified");
553 /* We want the output from gdb_breakpoint_query to go to
554 mi->event_channel. One approach would be to just
555 call gdb_breakpoint_query, and then use mi_out_put to
556 send the current content of mi_outout into mi->event_channel.
557 However, that will break if anything is output to mi_uiout
558 prior the calling the breakpoint_created notifications.
559 So, we use ui_out_redirect. */
560 ui_out_redirect (mi_uiout, mi->event_channel);
561 TRY_CATCH (e, RETURN_MASK_ERROR)
562 gdb_breakpoint_query (mi_uiout, b->number, NULL);
563 ui_out_redirect (mi_uiout, NULL);
565 gdb_flush (mi->event_channel);
570 mi_output_running_pid (struct thread_info *info, void *arg)
574 if (ptid_get_pid (*ptid) == ptid_get_pid (info->ptid))
575 fprintf_unfiltered (raw_stdout,
576 "*running,thread-id=\"%d\"\n",
583 mi_inferior_count (struct inferior *inf, void *arg)
595 mi_on_resume (ptid_t ptid)
597 struct thread_info *tp = NULL;
599 if (ptid_equal (ptid, minus_one_ptid) || ptid_is_pid (ptid))
600 tp = inferior_thread ();
602 tp = find_thread_ptid (ptid);
604 /* Suppress output while calling an inferior function. */
605 if (tp->control.in_infcall)
608 /* To cater for older frontends, emit ^running, but do it only once
609 per each command. We do it here, since at this point we know
610 that the target was successfully resumed, and in non-async mode,
611 we won't return back to MI interpreter code until the target
612 is done running, so delaying the output of "^running" until then
613 will make it impossible for frontend to know what's going on.
615 In future (MI3), we'll be outputting "^done" here. */
616 if (!running_result_record_printed && mi_proceeded)
618 fprintf_unfiltered (raw_stdout, "%s^running\n",
619 current_token ? current_token : "");
622 if (PIDGET (ptid) == -1)
623 fprintf_unfiltered (raw_stdout, "*running,thread-id=\"all\"\n");
624 else if (ptid_is_pid (ptid))
628 /* Backwards compatibility. If there's only one inferior,
629 output "all", otherwise, output each resumed thread
631 iterate_over_inferiors (mi_inferior_count, &count);
634 fprintf_unfiltered (raw_stdout, "*running,thread-id=\"all\"\n");
636 iterate_over_threads (mi_output_running_pid, &ptid);
640 struct thread_info *ti = find_thread_ptid (ptid);
643 fprintf_unfiltered (raw_stdout, "*running,thread-id=\"%d\"\n", ti->num);
646 if (!running_result_record_printed && mi_proceeded)
648 running_result_record_printed = 1;
649 /* This is what gdb used to do historically -- printing prompt even if
650 it cannot actually accept any input. This will be surely removed
651 for MI3, and may be removed even earler. */
652 /* FIXME: review the use of target_is_async_p here -- is that
654 if (!target_is_async_p ())
655 fputs_unfiltered ("(gdb) \n", raw_stdout);
657 gdb_flush (raw_stdout);
661 mi_solib_loaded (struct so_list *solib)
663 struct mi_interp *mi = top_level_interpreter_data ();
665 target_terminal_ours ();
666 if (gdbarch_has_global_solist (target_gdbarch))
667 fprintf_unfiltered (mi->event_channel,
668 "library-loaded,id=\"%s\",target-name=\"%s\","
669 "host-name=\"%s\",symbols-loaded=\"%d\"",
670 solib->so_original_name, solib->so_original_name,
671 solib->so_name, solib->symbols_loaded);
673 fprintf_unfiltered (mi->event_channel,
674 "library-loaded,id=\"%s\",target-name=\"%s\","
675 "host-name=\"%s\",symbols-loaded=\"%d\","
676 "thread-group=\"i%d\"",
677 solib->so_original_name, solib->so_original_name,
678 solib->so_name, solib->symbols_loaded,
679 current_inferior ()->num);
681 gdb_flush (mi->event_channel);
685 mi_solib_unloaded (struct so_list *solib)
687 struct mi_interp *mi = top_level_interpreter_data ();
689 target_terminal_ours ();
690 if (gdbarch_has_global_solist (target_gdbarch))
691 fprintf_unfiltered (mi->event_channel,
692 "library-unloaded,id=\"%s\",target-name=\"%s\","
694 solib->so_original_name, solib->so_original_name,
697 fprintf_unfiltered (mi->event_channel,
698 "library-unloaded,id=\"%s\",target-name=\"%s\","
699 "host-name=\"%s\",thread-group=\"i%d\"",
700 solib->so_original_name, solib->so_original_name,
701 solib->so_name, current_inferior ()->num);
703 gdb_flush (mi->event_channel);
707 report_initial_inferior (struct inferior *inf, void *closure)
709 /* This function is called from mi_intepreter_init, and since
710 mi_inferior_added assumes that inferior is fully initialized
711 and top_level_interpreter_data is set, we cannot call
713 struct mi_interp *mi = closure;
715 target_terminal_ours ();
716 fprintf_unfiltered (mi->event_channel,
717 "thread-group-added,id=\"i%d\"",
719 gdb_flush (mi->event_channel);
723 static struct ui_out *
724 mi_ui_out (struct interp *interp)
726 struct mi_interp *mi = interp_data (interp);
731 extern initialize_file_ftype _initialize_mi_interp; /* -Wmissing-prototypes */
734 _initialize_mi_interp (void)
736 static const struct interp_procs procs =
738 mi_interpreter_init, /* init_proc */
739 mi_interpreter_resume, /* resume_proc */
740 mi_interpreter_suspend, /* suspend_proc */
741 mi_interpreter_exec, /* exec_proc */
742 mi_interpreter_prompt_p, /* prompt_proc_p */
743 mi_ui_out /* ui_out_proc */
746 /* The various interpreter levels. */
747 interp_add (interp_new (INTERP_MI1, &procs));
748 interp_add (interp_new (INTERP_MI2, &procs));
749 interp_add (interp_new (INTERP_MI3, &procs));
750 interp_add (interp_new (INTERP_MI, &procs));