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"
39 /* These are the interpreter setup, etc. functions for the MI interpreter */
40 static void mi_execute_command_wrapper (char *cmd
);
41 static void mi_command_loop (int mi_version
);
43 /* These are hooks that we put in place while doing interpreter_exec
44 so we can report interesting things that happened "behind the mi's
45 back" in this command */
46 static int mi_interp_query_hook (const char *ctlstr
, va_list ap
)
47 ATTRIBUTE_PRINTF (1, 0);
49 static void mi3_command_loop (void);
50 static void mi2_command_loop (void);
51 static void mi1_command_loop (void);
53 static void mi_insert_notify_hooks (void);
54 static void mi_remove_notify_hooks (void);
55 static void mi_on_normal_stop (struct bpstats
*bs
, int print_frame
);
57 static void mi_new_thread (struct thread_info
*t
);
58 static void mi_thread_exit (struct thread_info
*t
, int silent
);
59 static void mi_inferior_added (struct inferior
*inf
);
60 static void mi_inferior_appeared (struct inferior
*inf
);
61 static void mi_inferior_exit (struct inferior
*inf
);
62 static void mi_inferior_removed (struct inferior
*inf
);
63 static void mi_on_resume (ptid_t ptid
);
64 static void mi_solib_loaded (struct so_list
*solib
);
65 static void mi_solib_unloaded (struct so_list
*solib
);
66 static void mi_about_to_proceed (void);
68 static int report_initial_inferior (struct inferior
*inf
, void *closure
);
71 mi_interpreter_init (int top_level
)
73 struct mi_interp
*mi
= XMALLOC (struct mi_interp
);
75 /* HACK: We need to force stdout/stderr to point at the console. This avoids
76 any potential side effects caused by legacy code that is still
77 using the TUI / fputs_unfiltered_hook. So we set up output channels for
78 this now, and swap them in when we are run. */
80 raw_stdout
= stdio_fileopen (stdout
);
82 /* Create MI channels */
83 mi
->out
= mi_console_file_new (raw_stdout
, "~", '"');
84 mi
->err
= mi_console_file_new (raw_stdout
, "&", '"');
86 mi
->targ
= mi_console_file_new (raw_stdout
, "@", '"');
87 mi
->event_channel
= mi_console_file_new (raw_stdout
, "=", 0);
91 observer_attach_new_thread (mi_new_thread
);
92 observer_attach_thread_exit (mi_thread_exit
);
93 observer_attach_inferior_added (mi_inferior_added
);
94 observer_attach_inferior_appeared (mi_inferior_appeared
);
95 observer_attach_inferior_exit (mi_inferior_exit
);
96 observer_attach_inferior_removed (mi_inferior_removed
);
97 observer_attach_normal_stop (mi_on_normal_stop
);
98 observer_attach_target_resumed (mi_on_resume
);
99 observer_attach_solib_loaded (mi_solib_loaded
);
100 observer_attach_solib_unloaded (mi_solib_unloaded
);
101 observer_attach_about_to_proceed (mi_about_to_proceed
);
103 /* The initial inferior is created before this function is called, so we
104 need to report it explicitly. Use iteration in case future version
105 of GDB creates more than one inferior up-front. */
106 iterate_over_inferiors (report_initial_inferior
, mi
);
113 mi_interpreter_resume (void *data
)
115 struct mi_interp
*mi
= data
;
117 /* As per hack note in mi_interpreter_init, swap in the output channels... */
118 gdb_setup_readline ();
120 /* These overwrite some of the initialization done in
121 _intialize_event_loop. */
122 call_readline
= gdb_readline2
;
123 input_handler
= mi_execute_command_wrapper
;
124 add_file_handler (input_fd
, stdin_event_handler
, 0);
125 async_command_editing_p
= 0;
126 /* FIXME: This is a total hack for now. PB's use of the MI
127 implicitly relies on a bug in the async support which allows
128 asynchronous commands to leak through the commmand loop. The bug
129 involves (but is not limited to) the fact that sync_execution was
130 erroneously initialized to 0. Duplicate by initializing it thus
134 gdb_stdout
= mi
->out
;
135 /* Route error and log output through the MI */
136 gdb_stderr
= mi
->err
;
137 gdb_stdlog
= mi
->log
;
138 /* Route target output through the MI. */
139 gdb_stdtarg
= mi
->targ
;
140 /* Route target error through the MI as well. */
141 gdb_stdtargerr
= mi
->targ
;
143 /* Replace all the hooks that we know about. There really needs to
144 be a better way of doing this... */
145 clear_interpreter_hooks ();
147 deprecated_show_load_progress
= mi_load_progress
;
149 /* If we're _the_ interpreter, take control. */
150 if (current_interp_named_p (INTERP_MI1
))
151 deprecated_command_loop_hook
= mi1_command_loop
;
152 else if (current_interp_named_p (INTERP_MI2
))
153 deprecated_command_loop_hook
= mi2_command_loop
;
154 else if (current_interp_named_p (INTERP_MI3
))
155 deprecated_command_loop_hook
= mi3_command_loop
;
157 deprecated_command_loop_hook
= mi2_command_loop
;
163 mi_interpreter_suspend (void *data
)
165 gdb_disable_readline ();
169 static struct gdb_exception
170 mi_interpreter_exec (void *data
, const char *command
)
172 char *tmp
= alloca (strlen (command
) + 1);
174 strcpy (tmp
, command
);
175 mi_execute_command_wrapper (tmp
);
176 return exception_none
;
179 /* Never display the default gdb prompt in mi case. */
181 mi_interpreter_prompt_p (void *data
)
187 mi_cmd_interpreter_exec (char *command
, char **argv
, int argc
)
189 struct interp
*interp_to_use
;
191 char *mi_error_message
= NULL
;
192 struct cleanup
*old_chain
;
195 error (_("mi_cmd_interpreter_exec: "
196 "Usage: -interpreter-exec interp command"));
198 interp_to_use
= interp_lookup (argv
[0]);
199 if (interp_to_use
== NULL
)
200 error (_("mi_cmd_interpreter_exec: could not find interpreter \"%s\""),
203 if (!interp_exec_p (interp_to_use
))
204 error (_("mi_cmd_interpreter_exec: interpreter \"%s\" "
205 "does not support command execution"),
208 /* Insert the MI out hooks, making sure to also call the interpreter's hooks
210 /* KRS: We shouldn't need this... Events should be installed and they should
211 just ALWAYS fire something out down the MI channel... */
212 mi_insert_notify_hooks ();
214 /* Now run the code... */
216 old_chain
= make_cleanup (null_cleanup
, 0);
217 for (i
= 1; i
< argc
; i
++)
219 struct gdb_exception e
= interp_exec (interp_to_use
, argv
[i
]);
223 mi_error_message
= xstrdup (e
.message
);
224 make_cleanup (xfree
, mi_error_message
);
229 mi_remove_notify_hooks ();
231 if (mi_error_message
!= NULL
)
232 error ("%s", mi_error_message
);
233 do_cleanups (old_chain
);
237 * mi_insert_notify_hooks - This inserts a number of hooks that are
238 * meant to produce async-notify ("=") MI messages while running
239 * commands in another interpreter using mi_interpreter_exec. The
240 * canonical use for this is to allow access to the gdb CLI
241 * interpreter from within the MI, while still producing MI style
242 * output when actions in the CLI command change gdb's state.
246 mi_insert_notify_hooks (void)
248 deprecated_query_hook
= mi_interp_query_hook
;
252 mi_remove_notify_hooks (void)
254 deprecated_query_hook
= NULL
;
258 mi_interp_query_hook (const char *ctlstr
, va_list ap
)
264 mi_execute_command_wrapper (char *cmd
)
266 mi_execute_command (cmd
, stdin
== instream
);
270 mi1_command_loop (void)
276 mi2_command_loop (void)
282 mi3_command_loop (void)
288 mi_command_loop (int mi_version
)
290 /* Turn off 8 bit strings in quoted output. Any character with the
291 high bit set is printed using C's octal format. */
292 sevenbit_strings
= 1;
293 /* Tell the world that we're alive */
294 fputs_unfiltered ("(gdb) \n", raw_stdout
);
295 gdb_flush (raw_stdout
);
300 mi_new_thread (struct thread_info
*t
)
302 struct mi_interp
*mi
= top_level_interpreter_data ();
303 struct inferior
*inf
= find_inferior_pid (ptid_get_pid (t
->ptid
));
307 fprintf_unfiltered (mi
->event_channel
,
308 "thread-created,id=\"%d\",group-id=\"i%d\"",
310 gdb_flush (mi
->event_channel
);
314 mi_thread_exit (struct thread_info
*t
, int silent
)
316 struct mi_interp
*mi
;
317 struct inferior
*inf
;
322 inf
= find_inferior_pid (ptid_get_pid (t
->ptid
));
324 mi
= top_level_interpreter_data ();
325 target_terminal_ours ();
326 fprintf_unfiltered (mi
->event_channel
,
327 "thread-exited,id=\"%d\",group-id=\"i%d\"",
329 gdb_flush (mi
->event_channel
);
333 mi_inferior_added (struct inferior
*inf
)
335 struct mi_interp
*mi
= top_level_interpreter_data ();
337 target_terminal_ours ();
338 fprintf_unfiltered (mi
->event_channel
,
339 "thread-group-added,id=\"i%d\"",
341 gdb_flush (mi
->event_channel
);
345 mi_inferior_appeared (struct inferior
*inf
)
347 struct mi_interp
*mi
= top_level_interpreter_data ();
349 target_terminal_ours ();
350 fprintf_unfiltered (mi
->event_channel
,
351 "thread-group-started,id=\"i%d\",pid=\"%d\"",
353 gdb_flush (mi
->event_channel
);
357 mi_inferior_exit (struct inferior
*inf
)
359 struct mi_interp
*mi
= top_level_interpreter_data ();
361 target_terminal_ours ();
362 fprintf_unfiltered (mi
->event_channel
, "thread-group-exited,id=\"i%d\"",
364 gdb_flush (mi
->event_channel
);
368 mi_inferior_removed (struct inferior
*inf
)
370 struct mi_interp
*mi
= top_level_interpreter_data ();
372 target_terminal_ours ();
373 fprintf_unfiltered (mi
->event_channel
,
374 "thread-group-removed,id=\"i%d\"",
376 gdb_flush (mi
->event_channel
);
380 mi_on_normal_stop (struct bpstats
*bs
, int print_frame
)
382 /* Since this can be called when CLI command is executing,
383 using cli interpreter, be sure to use MI uiout for output,
384 not the current one. */
385 struct ui_out
*mi_uiout
= interp_ui_out (top_level_interpreter ());
391 if (uiout
!= mi_uiout
)
393 /* The normal_stop function has printed frame information into
394 CLI uiout, or some other non-MI uiout. There's no way we
395 can extract proper fields from random uiout object, so we print
396 the frame again. In practice, this can only happen when running
397 a CLI command in MI. */
398 struct ui_out
*saved_uiout
= uiout
;
401 print_stack_frame (get_selected_frame (NULL
), 0, SRC_AND_LOC
);
405 ui_out_field_int (mi_uiout
, "thread-id",
406 pid_to_thread_id (inferior_ptid
));
409 struct cleanup
*back_to
= make_cleanup_ui_out_list_begin_end
410 (mi_uiout
, "stopped-threads");
412 ui_out_field_int (mi_uiout
, NULL
,
413 pid_to_thread_id (inferior_ptid
));
414 do_cleanups (back_to
);
417 ui_out_field_string (mi_uiout
, "stopped-threads", "all");
419 core
= target_core_of_thread (inferior_ptid
);
421 ui_out_field_int (mi_uiout
, "core", core
);
424 fputs_unfiltered ("*stopped", raw_stdout
);
425 mi_out_put (mi_uiout
, raw_stdout
);
426 mi_out_rewind (mi_uiout
);
427 mi_print_timing_maybe ();
428 fputs_unfiltered ("\n", raw_stdout
);
429 gdb_flush (raw_stdout
);
433 mi_about_to_proceed (void)
435 /* Suppress output while calling an inferior function. */
437 if (!ptid_equal (inferior_ptid
, null_ptid
))
439 struct thread_info
*tp
= inferior_thread ();
441 if (tp
->control
.in_infcall
)
449 mi_output_running_pid (struct thread_info
*info
, void *arg
)
453 if (ptid_get_pid (*ptid
) == ptid_get_pid (info
->ptid
))
454 fprintf_unfiltered (raw_stdout
,
455 "*running,thread-id=\"%d\"\n",
462 mi_inferior_count (struct inferior
*inf
, void *arg
)
474 mi_on_resume (ptid_t ptid
)
476 struct thread_info
*tp
= NULL
;
478 if (ptid_equal (ptid
, minus_one_ptid
) || ptid_is_pid (ptid
))
479 tp
= inferior_thread ();
481 tp
= find_thread_ptid (ptid
);
483 /* Suppress output while calling an inferior function. */
484 if (tp
->control
.in_infcall
)
487 /* To cater for older frontends, emit ^running, but do it only once
488 per each command. We do it here, since at this point we know
489 that the target was successfully resumed, and in non-async mode,
490 we won't return back to MI interpreter code until the target
491 is done running, so delaying the output of "^running" until then
492 will make it impossible for frontend to know what's going on.
494 In future (MI3), we'll be outputting "^done" here. */
495 if (!running_result_record_printed
&& mi_proceeded
)
497 fprintf_unfiltered (raw_stdout
, "%s^running\n",
498 current_token
? current_token
: "");
501 if (PIDGET (ptid
) == -1)
502 fprintf_unfiltered (raw_stdout
, "*running,thread-id=\"all\"\n");
503 else if (ptid_is_pid (ptid
))
507 /* Backwards compatibility. If there's only one inferior,
508 output "all", otherwise, output each resumed thread
510 iterate_over_inferiors (mi_inferior_count
, &count
);
513 fprintf_unfiltered (raw_stdout
, "*running,thread-id=\"all\"\n");
515 iterate_over_threads (mi_output_running_pid
, &ptid
);
519 struct thread_info
*ti
= find_thread_ptid (ptid
);
522 fprintf_unfiltered (raw_stdout
, "*running,thread-id=\"%d\"\n", ti
->num
);
525 if (!running_result_record_printed
&& mi_proceeded
)
527 running_result_record_printed
= 1;
528 /* This is what gdb used to do historically -- printing prompt even if
529 it cannot actually accept any input. This will be surely removed
530 for MI3, and may be removed even earler. */
531 /* FIXME: review the use of target_is_async_p here -- is that
533 if (!target_is_async_p ())
534 fputs_unfiltered ("(gdb) \n", raw_stdout
);
536 gdb_flush (raw_stdout
);
540 mi_solib_loaded (struct so_list
*solib
)
542 struct mi_interp
*mi
= top_level_interpreter_data ();
544 target_terminal_ours ();
545 if (gdbarch_has_global_solist (target_gdbarch
))
546 fprintf_unfiltered (mi
->event_channel
,
547 "library-loaded,id=\"%s\",target-name=\"%s\","
548 "host-name=\"%s\",symbols-loaded=\"%d\"",
549 solib
->so_original_name
, solib
->so_original_name
,
550 solib
->so_name
, solib
->symbols_loaded
);
552 fprintf_unfiltered (mi
->event_channel
,
553 "library-loaded,id=\"%s\",target-name=\"%s\","
554 "host-name=\"%s\",symbols-loaded=\"%d\","
555 "thread-group=\"i%d\"",
556 solib
->so_original_name
, solib
->so_original_name
,
557 solib
->so_name
, solib
->symbols_loaded
,
558 current_inferior ()->num
);
560 gdb_flush (mi
->event_channel
);
564 mi_solib_unloaded (struct so_list
*solib
)
566 struct mi_interp
*mi
= top_level_interpreter_data ();
568 target_terminal_ours ();
569 if (gdbarch_has_global_solist (target_gdbarch
))
570 fprintf_unfiltered (mi
->event_channel
,
571 "library-unloaded,id=\"%s\",target-name=\"%s\","
573 solib
->so_original_name
, solib
->so_original_name
,
576 fprintf_unfiltered (mi
->event_channel
,
577 "library-unloaded,id=\"%s\",target-name=\"%s\","
578 "host-name=\"%s\",thread-group=\"i%d\"",
579 solib
->so_original_name
, solib
->so_original_name
,
580 solib
->so_name
, current_inferior ()->num
);
582 gdb_flush (mi
->event_channel
);
586 report_initial_inferior (struct inferior
*inf
, void *closure
)
588 /* This function is called from mi_intepreter_init, and since
589 mi_inferior_added assumes that inferior is fully initialized
590 and top_level_interpreter_data is set, we cannot call
592 struct mi_interp
*mi
= closure
;
594 target_terminal_ours ();
595 fprintf_unfiltered (mi
->event_channel
,
596 "thread-group-added,id=\"i%d\"",
598 gdb_flush (mi
->event_channel
);
602 extern initialize_file_ftype _initialize_mi_interp
; /* -Wmissing-prototypes */
605 _initialize_mi_interp (void)
607 static const struct interp_procs procs
=
609 mi_interpreter_init
, /* init_proc */
610 mi_interpreter_resume
, /* resume_proc */
611 mi_interpreter_suspend
, /* suspend_proc */
612 mi_interpreter_exec
, /* exec_proc */
613 mi_interpreter_prompt_p
/* prompt_proc_p */
616 /* The various interpreter levels. */
617 interp_add (interp_new (INTERP_MI1
, NULL
, mi_out_new (1), &procs
));
618 interp_add (interp_new (INTERP_MI2
, NULL
, mi_out_new (2), &procs
));
619 interp_add (interp_new (INTERP_MI3
, NULL
, mi_out_new (3), &procs
));
621 /* "mi" selects the most recent released version. "mi2" was
622 released as part of GDB 6.0. */
623 interp_add (interp_new (INTERP_MI
, NULL
, mi_out_new (2), &procs
));