1 /* MI Interpreter Definitions and Commands for GDB, the GNU debugger.
3 Copyright (C) 2002-2013 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 #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);
57 static void mi_on_normal_stop (struct bpstats *bs, int print_frame);
59 static void mi_new_thread (struct thread_info *t);
60 static void mi_thread_exit (struct thread_info *t, int silent);
61 static void mi_record_changed (struct inferior*, int);
62 static void mi_inferior_added (struct inferior *inf);
63 static void mi_inferior_appeared (struct inferior *inf);
64 static void mi_inferior_exit (struct inferior *inf);
65 static void mi_inferior_removed (struct inferior *inf);
66 static void mi_on_resume (ptid_t ptid);
67 static void mi_solib_loaded (struct so_list *solib);
68 static void mi_solib_unloaded (struct so_list *solib);
69 static void mi_about_to_proceed (void);
70 static void mi_traceframe_changed (int tfnum, int tpnum);
71 static void mi_tsv_created (const struct trace_state_variable *tsv);
72 static void mi_tsv_deleted (const struct trace_state_variable *tsv);
73 static void mi_tsv_modified (const struct trace_state_variable *tsv);
74 static void mi_breakpoint_created (struct breakpoint *b);
75 static void mi_breakpoint_deleted (struct breakpoint *b);
76 static void mi_breakpoint_modified (struct breakpoint *b);
77 static void mi_command_param_changed (const char *param, const char *value);
78 static void mi_memory_changed (struct inferior *inf, CORE_ADDR memaddr,
79 ssize_t len, const bfd_byte *myaddr);
81 static int report_initial_inferior (struct inferior *inf, void *closure);
84 mi_interpreter_init (struct interp *interp, int top_level)
86 struct mi_interp *mi = XMALLOC (struct mi_interp);
90 /* Assign the output channel created at startup to its own global,
91 so that we can create a console channel that encapsulates and
92 prefixes all gdb_output-type bits coming from the rest of the
95 raw_stdout = gdb_stdout;
97 /* Create MI console channels, each with a different prefix so they
98 can be distinguished. */
99 mi->out = mi_console_file_new (raw_stdout, "~", '"');
100 mi->err = mi_console_file_new (raw_stdout, "&", '"');
102 mi->targ = mi_console_file_new (raw_stdout, "@", '"');
103 mi->event_channel = mi_console_file_new (raw_stdout, "=", 0);
105 name = interp_name (interp);
106 /* INTERP_MI selects the most recent released version. "mi2" was
107 released as part of GDB 6.0. */
108 if (strcmp (name, INTERP_MI) == 0)
110 else if (strcmp (name, INTERP_MI1) == 0)
112 else if (strcmp (name, INTERP_MI2) == 0)
114 else if (strcmp (name, INTERP_MI3) == 0)
117 gdb_assert_not_reached ("unhandled MI version");
119 mi->uiout = mi_out_new (mi_version);
123 observer_attach_new_thread (mi_new_thread);
124 observer_attach_thread_exit (mi_thread_exit);
125 observer_attach_inferior_added (mi_inferior_added);
126 observer_attach_inferior_appeared (mi_inferior_appeared);
127 observer_attach_inferior_exit (mi_inferior_exit);
128 observer_attach_inferior_removed (mi_inferior_removed);
129 observer_attach_record_changed (mi_record_changed);
130 observer_attach_normal_stop (mi_on_normal_stop);
131 observer_attach_target_resumed (mi_on_resume);
132 observer_attach_solib_loaded (mi_solib_loaded);
133 observer_attach_solib_unloaded (mi_solib_unloaded);
134 observer_attach_about_to_proceed (mi_about_to_proceed);
135 observer_attach_traceframe_changed (mi_traceframe_changed);
136 observer_attach_tsv_created (mi_tsv_created);
137 observer_attach_tsv_deleted (mi_tsv_deleted);
138 observer_attach_tsv_modified (mi_tsv_modified);
139 observer_attach_breakpoint_created (mi_breakpoint_created);
140 observer_attach_breakpoint_deleted (mi_breakpoint_deleted);
141 observer_attach_breakpoint_modified (mi_breakpoint_modified);
142 observer_attach_command_param_changed (mi_command_param_changed);
143 observer_attach_memory_changed (mi_memory_changed);
145 /* The initial inferior is created before this function is
146 called, so we need to report it explicitly. Use iteration in
147 case future version of GDB creates more than one inferior
149 iterate_over_inferiors (report_initial_inferior, mi);
156 mi_interpreter_resume (void *data)
158 struct mi_interp *mi = data;
160 /* As per hack note in mi_interpreter_init, swap in the output
162 gdb_setup_readline ();
164 /* These overwrite some of the initialization done in
165 _intialize_event_loop. */
166 call_readline = gdb_readline2;
167 input_handler = mi_execute_command_input_handler;
168 async_command_editing_p = 0;
169 /* FIXME: This is a total hack for now. PB's use of the MI
170 implicitly relies on a bug in the async support which allows
171 asynchronous commands to leak through the commmand loop. The bug
172 involves (but is not limited to) the fact that sync_execution was
173 erroneously initialized to 0. Duplicate by initializing it thus
177 gdb_stdout = mi->out;
178 /* Route error and log output through the MI. */
179 gdb_stderr = mi->err;
180 gdb_stdlog = mi->log;
181 /* Route target output through the MI. */
182 gdb_stdtarg = mi->targ;
183 /* Route target error through the MI as well. */
184 gdb_stdtargerr = mi->targ;
186 /* Replace all the hooks that we know about. There really needs to
187 be a better way of doing this... */
188 clear_interpreter_hooks ();
190 deprecated_show_load_progress = mi_load_progress;
196 mi_interpreter_suspend (void *data)
198 gdb_disable_readline ();
202 static struct gdb_exception
203 mi_interpreter_exec (void *data, const char *command)
205 mi_execute_command_wrapper (command);
206 return exception_none;
209 /* Never display the default GDB prompt in MI case. */
212 mi_interpreter_prompt_p (void *data)
218 mi_cmd_interpreter_exec (char *command, char **argv, int argc)
220 struct interp *interp_to_use;
222 char *mi_error_message = NULL;
223 struct cleanup *old_chain;
226 error (_("-interpreter-exec: "
227 "Usage: -interpreter-exec interp command"));
229 interp_to_use = interp_lookup (argv[0]);
230 if (interp_to_use == NULL)
231 error (_("-interpreter-exec: could not find interpreter \"%s\""),
234 if (!interp_exec_p (interp_to_use))
235 error (_("-interpreter-exec: interpreter \"%s\" "
236 "does not support command execution"),
239 /* Insert the MI out hooks, making sure to also call the
240 interpreter's hooks if it has any. */
241 /* KRS: We shouldn't need this... Events should be installed and
242 they should just ALWAYS fire something out down the MI
244 mi_insert_notify_hooks ();
246 /* Now run the code. */
248 old_chain = make_cleanup (null_cleanup, 0);
249 for (i = 1; i < argc; i++)
251 struct gdb_exception e = interp_exec (interp_to_use, argv[i]);
255 mi_error_message = xstrdup (e.message);
256 make_cleanup (xfree, mi_error_message);
261 mi_remove_notify_hooks ();
263 if (mi_error_message != NULL)
264 error ("%s", mi_error_message);
265 do_cleanups (old_chain);
268 /* This inserts a number of hooks that are meant to produce
269 async-notify ("=") MI messages while running commands in another
270 interpreter using mi_interpreter_exec. The canonical use for this
271 is to allow access to the gdb CLI interpreter from within the MI,
272 while still producing MI style output when actions in the CLI
273 command change GDB's state. */
276 mi_insert_notify_hooks (void)
278 deprecated_query_hook = mi_interp_query_hook;
282 mi_remove_notify_hooks (void)
284 deprecated_query_hook = NULL;
288 mi_interp_query_hook (const char *ctlstr, va_list ap)
294 mi_execute_command_wrapper (const char *cmd)
296 mi_execute_command (cmd, stdin == instream);
299 /* mi_execute_command_wrapper wrapper suitable for INPUT_HANDLER. */
302 mi_execute_command_input_handler (char *cmd)
304 mi_execute_command_wrapper (cmd);
306 fputs_unfiltered ("(gdb) \n", raw_stdout);
307 gdb_flush (raw_stdout);
311 mi_command_loop (void *data)
313 /* Turn off 8 bit strings in quoted output. Any character with the
314 high bit set is printed using C's octal format. */
315 sevenbit_strings = 1;
317 /* Tell the world that we're alive. */
318 fputs_unfiltered ("(gdb) \n", raw_stdout);
319 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);
357 /* Emit notification on changing the state of record. */
360 mi_record_changed (struct inferior *inferior, int started)
362 struct mi_interp *mi = top_level_interpreter_data ();
364 fprintf_unfiltered (mi->event_channel, "record-%s,thread-group=\"i%d\"",
365 started ? "started" : "stopped", inferior->num);
367 gdb_flush (mi->event_channel);
371 mi_inferior_added (struct inferior *inf)
373 struct mi_interp *mi = top_level_interpreter_data ();
375 target_terminal_ours ();
376 fprintf_unfiltered (mi->event_channel,
377 "thread-group-added,id=\"i%d\"",
379 gdb_flush (mi->event_channel);
383 mi_inferior_appeared (struct inferior *inf)
385 struct mi_interp *mi = top_level_interpreter_data ();
387 target_terminal_ours ();
388 fprintf_unfiltered (mi->event_channel,
389 "thread-group-started,id=\"i%d\",pid=\"%d\"",
391 gdb_flush (mi->event_channel);
395 mi_inferior_exit (struct inferior *inf)
397 struct mi_interp *mi = top_level_interpreter_data ();
399 target_terminal_ours ();
400 if (inf->has_exit_code)
401 fprintf_unfiltered (mi->event_channel,
402 "thread-group-exited,id=\"i%d\",exit-code=\"%s\"",
403 inf->num, int_string (inf->exit_code, 8, 0, 0, 1));
405 fprintf_unfiltered (mi->event_channel,
406 "thread-group-exited,id=\"i%d\"", inf->num);
408 gdb_flush (mi->event_channel);
412 mi_inferior_removed (struct inferior *inf)
414 struct mi_interp *mi = top_level_interpreter_data ();
416 target_terminal_ours ();
417 fprintf_unfiltered (mi->event_channel,
418 "thread-group-removed,id=\"i%d\"",
420 gdb_flush (mi->event_channel);
424 mi_on_normal_stop (struct bpstats *bs, int print_frame)
426 /* Since this can be called when CLI command is executing,
427 using cli interpreter, be sure to use MI uiout for output,
428 not the current one. */
429 struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
435 if (current_uiout != mi_uiout)
437 /* The normal_stop function has printed frame information
438 into CLI uiout, or some other non-MI uiout. There's no
439 way we can extract proper fields from random uiout
440 object, so we print the frame again. In practice, this
441 can only happen when running a CLI command in MI. */
442 struct ui_out *saved_uiout = current_uiout;
443 struct target_waitstatus last;
446 current_uiout = mi_uiout;
448 get_last_target_status (&last_ptid, &last);
449 bpstat_print (bs, last.kind);
451 print_stack_frame (get_selected_frame (NULL), 0, SRC_AND_LOC, 1);
452 current_uiout = saved_uiout;
455 ui_out_field_int (mi_uiout, "thread-id",
456 pid_to_thread_id (inferior_ptid));
459 struct cleanup *back_to = make_cleanup_ui_out_list_begin_end
460 (mi_uiout, "stopped-threads");
462 ui_out_field_int (mi_uiout, NULL,
463 pid_to_thread_id (inferior_ptid));
464 do_cleanups (back_to);
467 ui_out_field_string (mi_uiout, "stopped-threads", "all");
469 core = target_core_of_thread (inferior_ptid);
471 ui_out_field_int (mi_uiout, "core", core);
474 fputs_unfiltered ("*stopped", raw_stdout);
475 mi_out_put (mi_uiout, raw_stdout);
476 mi_out_rewind (mi_uiout);
477 mi_print_timing_maybe ();
478 fputs_unfiltered ("\n", raw_stdout);
479 gdb_flush (raw_stdout);
483 mi_about_to_proceed (void)
485 /* Suppress output while calling an inferior function. */
487 if (!ptid_equal (inferior_ptid, null_ptid))
489 struct thread_info *tp = inferior_thread ();
491 if (tp->control.in_infcall)
498 /* When the element is non-zero, no MI notifications will be emitted in
499 response to the corresponding observers. */
501 struct mi_suppress_notification mi_suppress_notification =
508 /* Emit notification on changing a traceframe. */
511 mi_traceframe_changed (int tfnum, int tpnum)
513 struct mi_interp *mi = top_level_interpreter_data ();
515 if (mi_suppress_notification.traceframe)
518 target_terminal_ours ();
521 fprintf_unfiltered (mi->event_channel, "traceframe-changed,"
522 "num=\"%d\",tracepoint=\"%d\"\n",
525 fprintf_unfiltered (mi->event_channel, "traceframe-changed,end");
527 gdb_flush (mi->event_channel);
530 /* Emit notification on creating a trace state variable. */
533 mi_tsv_created (const struct trace_state_variable *tsv)
535 struct mi_interp *mi = top_level_interpreter_data ();
537 target_terminal_ours ();
539 fprintf_unfiltered (mi->event_channel, "tsv-created,"
540 "name=\"%s\",initial=\"%s\"\n",
541 tsv->name, plongest (tsv->initial_value));
543 gdb_flush (mi->event_channel);
546 /* Emit notification on deleting a trace state variable. */
549 mi_tsv_deleted (const struct trace_state_variable *tsv)
551 struct mi_interp *mi = top_level_interpreter_data ();
553 target_terminal_ours ();
556 fprintf_unfiltered (mi->event_channel, "tsv-deleted,"
557 "name=\"%s\"\n", tsv->name);
559 fprintf_unfiltered (mi->event_channel, "tsv-deleted\n");
561 gdb_flush (mi->event_channel);
564 /* Emit notification on modifying a trace state variable. */
567 mi_tsv_modified (const struct trace_state_variable *tsv)
569 struct mi_interp *mi = top_level_interpreter_data ();
570 struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
572 target_terminal_ours ();
574 fprintf_unfiltered (mi->event_channel,
577 ui_out_redirect (mi_uiout, mi->event_channel);
579 ui_out_field_string (mi_uiout, "name", tsv->name);
580 ui_out_field_string (mi_uiout, "initial",
581 plongest (tsv->initial_value));
582 if (tsv->value_known)
583 ui_out_field_string (mi_uiout, "current", plongest (tsv->value));
585 ui_out_redirect (mi_uiout, NULL);
587 gdb_flush (mi->event_channel);
590 /* Emit notification about a created breakpoint. */
593 mi_breakpoint_created (struct breakpoint *b)
595 struct mi_interp *mi = top_level_interpreter_data ();
596 struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
597 volatile struct gdb_exception e;
599 if (mi_suppress_notification.breakpoint)
605 target_terminal_ours ();
606 fprintf_unfiltered (mi->event_channel,
607 "breakpoint-created");
608 /* We want the output from gdb_breakpoint_query to go to
609 mi->event_channel. One approach would be to just call
610 gdb_breakpoint_query, and then use mi_out_put to send the current
611 content of mi_outout into mi->event_channel. However, that will
612 break if anything is output to mi_uiout prior to calling the
613 breakpoint_created notifications. So, we use
615 ui_out_redirect (mi_uiout, mi->event_channel);
616 TRY_CATCH (e, RETURN_MASK_ERROR)
617 gdb_breakpoint_query (mi_uiout, b->number, NULL);
618 ui_out_redirect (mi_uiout, NULL);
620 gdb_flush (mi->event_channel);
623 /* Emit notification about deleted breakpoint. */
626 mi_breakpoint_deleted (struct breakpoint *b)
628 struct mi_interp *mi = top_level_interpreter_data ();
630 if (mi_suppress_notification.breakpoint)
636 target_terminal_ours ();
638 fprintf_unfiltered (mi->event_channel, "breakpoint-deleted,id=\"%d\"",
641 gdb_flush (mi->event_channel);
644 /* Emit notification about modified breakpoint. */
647 mi_breakpoint_modified (struct breakpoint *b)
649 struct mi_interp *mi = top_level_interpreter_data ();
650 struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
651 volatile struct gdb_exception e;
653 if (mi_suppress_notification.breakpoint)
659 target_terminal_ours ();
660 fprintf_unfiltered (mi->event_channel,
661 "breakpoint-modified");
662 /* We want the output from gdb_breakpoint_query to go to
663 mi->event_channel. One approach would be to just call
664 gdb_breakpoint_query, and then use mi_out_put to send the current
665 content of mi_outout into mi->event_channel. However, that will
666 break if anything is output to mi_uiout prior to calling the
667 breakpoint_created notifications. So, we use
669 ui_out_redirect (mi_uiout, mi->event_channel);
670 TRY_CATCH (e, RETURN_MASK_ERROR)
671 gdb_breakpoint_query (mi_uiout, b->number, NULL);
672 ui_out_redirect (mi_uiout, NULL);
674 gdb_flush (mi->event_channel);
678 mi_output_running_pid (struct thread_info *info, void *arg)
682 if (ptid_get_pid (*ptid) == ptid_get_pid (info->ptid))
683 fprintf_unfiltered (raw_stdout,
684 "*running,thread-id=\"%d\"\n",
691 mi_inferior_count (struct inferior *inf, void *arg)
703 mi_on_resume (ptid_t ptid)
705 struct thread_info *tp = NULL;
707 if (ptid_equal (ptid, minus_one_ptid) || ptid_is_pid (ptid))
708 tp = inferior_thread ();
710 tp = find_thread_ptid (ptid);
712 /* Suppress output while calling an inferior function. */
713 if (tp->control.in_infcall)
716 /* To cater for older frontends, emit ^running, but do it only once
717 per each command. We do it here, since at this point we know
718 that the target was successfully resumed, and in non-async mode,
719 we won't return back to MI interpreter code until the target
720 is done running, so delaying the output of "^running" until then
721 will make it impossible for frontend to know what's going on.
723 In future (MI3), we'll be outputting "^done" here. */
724 if (!running_result_record_printed && mi_proceeded)
726 fprintf_unfiltered (raw_stdout, "%s^running\n",
727 current_token ? current_token : "");
730 if (PIDGET (ptid) == -1)
731 fprintf_unfiltered (raw_stdout, "*running,thread-id=\"all\"\n");
732 else if (ptid_is_pid (ptid))
736 /* Backwards compatibility. If there's only one inferior,
737 output "all", otherwise, output each resumed thread
739 iterate_over_inferiors (mi_inferior_count, &count);
742 fprintf_unfiltered (raw_stdout, "*running,thread-id=\"all\"\n");
744 iterate_over_threads (mi_output_running_pid, &ptid);
748 struct thread_info *ti = find_thread_ptid (ptid);
751 fprintf_unfiltered (raw_stdout, "*running,thread-id=\"%d\"\n", ti->num);
754 if (!running_result_record_printed && mi_proceeded)
756 running_result_record_printed = 1;
757 /* This is what gdb used to do historically -- printing prompt even if
758 it cannot actually accept any input. This will be surely removed
759 for MI3, and may be removed even earler. */
760 /* FIXME: review the use of target_is_async_p here -- is that
762 if (!target_is_async_p ())
763 fputs_unfiltered ("(gdb) \n", raw_stdout);
765 gdb_flush (raw_stdout);
769 mi_solib_loaded (struct so_list *solib)
771 struct mi_interp *mi = top_level_interpreter_data ();
773 target_terminal_ours ();
774 if (gdbarch_has_global_solist (target_gdbarch ()))
775 fprintf_unfiltered (mi->event_channel,
776 "library-loaded,id=\"%s\",target-name=\"%s\","
777 "host-name=\"%s\",symbols-loaded=\"%d\"",
778 solib->so_original_name, solib->so_original_name,
779 solib->so_name, solib->symbols_loaded);
781 fprintf_unfiltered (mi->event_channel,
782 "library-loaded,id=\"%s\",target-name=\"%s\","
783 "host-name=\"%s\",symbols-loaded=\"%d\","
784 "thread-group=\"i%d\"",
785 solib->so_original_name, solib->so_original_name,
786 solib->so_name, solib->symbols_loaded,
787 current_inferior ()->num);
789 gdb_flush (mi->event_channel);
793 mi_solib_unloaded (struct so_list *solib)
795 struct mi_interp *mi = top_level_interpreter_data ();
797 target_terminal_ours ();
798 if (gdbarch_has_global_solist (target_gdbarch ()))
799 fprintf_unfiltered (mi->event_channel,
800 "library-unloaded,id=\"%s\",target-name=\"%s\","
802 solib->so_original_name, solib->so_original_name,
805 fprintf_unfiltered (mi->event_channel,
806 "library-unloaded,id=\"%s\",target-name=\"%s\","
807 "host-name=\"%s\",thread-group=\"i%d\"",
808 solib->so_original_name, solib->so_original_name,
809 solib->so_name, current_inferior ()->num);
811 gdb_flush (mi->event_channel);
814 /* Emit notification about the command parameter change. */
817 mi_command_param_changed (const char *param, const char *value)
819 struct mi_interp *mi = top_level_interpreter_data ();
820 struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
822 if (mi_suppress_notification.cmd_param_changed)
825 target_terminal_ours ();
827 fprintf_unfiltered (mi->event_channel,
828 "cmd-param-changed");
830 ui_out_redirect (mi_uiout, mi->event_channel);
832 ui_out_field_string (mi_uiout, "param", param);
833 ui_out_field_string (mi_uiout, "value", value);
835 ui_out_redirect (mi_uiout, NULL);
837 gdb_flush (mi->event_channel);
840 /* Emit notification about the target memory change. */
843 mi_memory_changed (struct inferior *inferior, CORE_ADDR memaddr,
844 ssize_t len, const bfd_byte *myaddr)
846 struct mi_interp *mi = top_level_interpreter_data ();
847 struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
848 struct obj_section *sec;
850 if (mi_suppress_notification.memory)
853 target_terminal_ours ();
855 fprintf_unfiltered (mi->event_channel,
858 ui_out_redirect (mi_uiout, mi->event_channel);
860 ui_out_field_fmt (mi_uiout, "thread-group", "i%d", inferior->num);
861 ui_out_field_core_addr (mi_uiout, "addr", target_gdbarch (), memaddr);
862 ui_out_field_fmt (mi_uiout, "len", "0x%zx", len);
864 /* Append 'type=code' into notification if MEMADDR falls in the range of
865 sections contain code. */
866 sec = find_pc_section (memaddr);
867 if (sec != NULL && sec->objfile != NULL)
869 flagword flags = bfd_get_section_flags (sec->objfile->obfd,
870 sec->the_bfd_section);
872 if (flags & SEC_CODE)
873 ui_out_field_string (mi_uiout, "type", "code");
876 ui_out_redirect (mi_uiout, NULL);
878 gdb_flush (mi->event_channel);
882 report_initial_inferior (struct inferior *inf, void *closure)
884 /* This function is called from mi_intepreter_init, and since
885 mi_inferior_added assumes that inferior is fully initialized
886 and top_level_interpreter_data is set, we cannot call
888 struct mi_interp *mi = closure;
890 target_terminal_ours ();
891 fprintf_unfiltered (mi->event_channel,
892 "thread-group-added,id=\"i%d\"",
894 gdb_flush (mi->event_channel);
898 static struct ui_out *
899 mi_ui_out (struct interp *interp)
901 struct mi_interp *mi = interp_data (interp);
906 /* Save the original value of raw_stdout here when logging, so we can
907 restore correctly when done. */
909 static struct ui_file *saved_raw_stdout;
911 /* Do MI-specific logging actions; save raw_stdout, and change all
912 the consoles to use the supplied ui-file(s). */
915 mi_set_logging (struct interp *interp, int start_log,
916 struct ui_file *out, struct ui_file *logfile)
918 struct mi_interp *mi = interp_data (interp);
925 /* The tee created already is based on gdb_stdout, which for MI
926 is a console and so we end up in an infinite loop of console
927 writing to ui_file writing to console etc. So discard the
928 existing tee (it hasn't been used yet, and MI won't ever use
929 it), and create one based on raw_stdout instead. */
932 ui_file_delete (out);
933 out = tee_file_new (raw_stdout, 0, logfile, 0);
936 saved_raw_stdout = raw_stdout;
941 raw_stdout = saved_raw_stdout;
942 saved_raw_stdout = NULL;
945 mi_console_set_raw (mi->out, raw_stdout);
946 mi_console_set_raw (mi->err, raw_stdout);
947 mi_console_set_raw (mi->log, raw_stdout);
948 mi_console_set_raw (mi->targ, raw_stdout);
949 mi_console_set_raw (mi->event_channel, raw_stdout);
954 extern initialize_file_ftype _initialize_mi_interp; /* -Wmissing-prototypes */
957 _initialize_mi_interp (void)
959 static const struct interp_procs procs =
961 mi_interpreter_init, /* init_proc */
962 mi_interpreter_resume, /* resume_proc */
963 mi_interpreter_suspend, /* suspend_proc */
964 mi_interpreter_exec, /* exec_proc */
965 mi_interpreter_prompt_p, /* prompt_proc_p */
966 mi_ui_out, /* ui_out_proc */
967 mi_set_logging, /* set_logging_proc */
968 mi_command_loop /* command_loop_proc */
971 /* The various interpreter levels. */
972 interp_add (interp_new (INTERP_MI1, &procs));
973 interp_add (interp_new (INTERP_MI2, &procs));
974 interp_add (interp_new (INTERP_MI3, &procs));
975 interp_add (interp_new (INTERP_MI, &procs));