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 (char *cmd
);
45 static void mi_execute_command_input_handler (char *cmd
);
46 static void mi_command_loop (int mi_version
);
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 mi3_command_loop (void);
56 static void mi2_command_loop (void);
57 static void mi1_command_loop (void);
59 static void mi_insert_notify_hooks (void);
60 static void mi_remove_notify_hooks (void);
61 static void mi_on_normal_stop (struct bpstats
*bs
, int print_frame
);
63 static void mi_new_thread (struct thread_info
*t
);
64 static void mi_thread_exit (struct thread_info
*t
, int silent
);
65 static void mi_record_changed (struct inferior
*, int);
66 static void mi_inferior_added (struct inferior
*inf
);
67 static void mi_inferior_appeared (struct inferior
*inf
);
68 static void mi_inferior_exit (struct inferior
*inf
);
69 static void mi_inferior_removed (struct inferior
*inf
);
70 static void mi_on_resume (ptid_t ptid
);
71 static void mi_solib_loaded (struct so_list
*solib
);
72 static void mi_solib_unloaded (struct so_list
*solib
);
73 static void mi_about_to_proceed (void);
74 static void mi_traceframe_changed (int tfnum
, int tpnum
);
75 static void mi_tsv_created (const struct trace_state_variable
*tsv
);
76 static void mi_tsv_deleted (const struct trace_state_variable
*tsv
);
77 static void mi_tsv_modified (const struct trace_state_variable
*tsv
);
78 static void mi_breakpoint_created (struct breakpoint
*b
);
79 static void mi_breakpoint_deleted (struct breakpoint
*b
);
80 static void mi_breakpoint_modified (struct breakpoint
*b
);
81 static void mi_command_param_changed (const char *param
, const char *value
);
82 static void mi_memory_changed (struct inferior
*inf
, CORE_ADDR memaddr
,
83 ssize_t len
, const bfd_byte
*myaddr
);
85 static int report_initial_inferior (struct inferior
*inf
, void *closure
);
88 mi_interpreter_init (struct interp
*interp
, int top_level
)
90 struct mi_interp
*mi
= XMALLOC (struct mi_interp
);
94 /* Assign the output channel created at startup to its own global,
95 so that we can create a console channel that encapsulates and
96 prefixes all gdb_output-type bits coming from the rest of the
99 raw_stdout
= gdb_stdout
;
101 /* Create MI console channels, each with a different prefix so they
102 can be distinguished. */
103 mi
->out
= mi_console_file_new (raw_stdout
, "~", '"');
104 mi
->err
= mi_console_file_new (raw_stdout
, "&", '"');
106 mi
->targ
= mi_console_file_new (raw_stdout
, "@", '"');
107 mi
->event_channel
= mi_console_file_new (raw_stdout
, "=", 0);
109 name
= interp_name (interp
);
110 /* INTERP_MI selects the most recent released version. "mi2" was
111 released as part of GDB 6.0. */
112 if (strcmp (name
, INTERP_MI
) == 0)
114 else if (strcmp (name
, INTERP_MI1
) == 0)
116 else if (strcmp (name
, INTERP_MI2
) == 0)
118 else if (strcmp (name
, INTERP_MI3
) == 0)
121 gdb_assert_not_reached ("unhandled MI version");
123 mi
->uiout
= mi_out_new (mi_version
);
127 observer_attach_new_thread (mi_new_thread
);
128 observer_attach_thread_exit (mi_thread_exit
);
129 observer_attach_inferior_added (mi_inferior_added
);
130 observer_attach_inferior_appeared (mi_inferior_appeared
);
131 observer_attach_inferior_exit (mi_inferior_exit
);
132 observer_attach_inferior_removed (mi_inferior_removed
);
133 observer_attach_record_changed (mi_record_changed
);
134 observer_attach_normal_stop (mi_on_normal_stop
);
135 observer_attach_target_resumed (mi_on_resume
);
136 observer_attach_solib_loaded (mi_solib_loaded
);
137 observer_attach_solib_unloaded (mi_solib_unloaded
);
138 observer_attach_about_to_proceed (mi_about_to_proceed
);
139 observer_attach_traceframe_changed (mi_traceframe_changed
);
140 observer_attach_tsv_created (mi_tsv_created
);
141 observer_attach_tsv_deleted (mi_tsv_deleted
);
142 observer_attach_tsv_modified (mi_tsv_modified
);
143 observer_attach_breakpoint_created (mi_breakpoint_created
);
144 observer_attach_breakpoint_deleted (mi_breakpoint_deleted
);
145 observer_attach_breakpoint_modified (mi_breakpoint_modified
);
146 observer_attach_command_param_changed (mi_command_param_changed
);
147 observer_attach_memory_changed (mi_memory_changed
);
149 /* The initial inferior is created before this function is
150 called, so we need to report it explicitly. Use iteration in
151 case future version of GDB creates more than one inferior
153 iterate_over_inferiors (report_initial_inferior
, mi
);
160 mi_interpreter_resume (void *data
)
162 struct mi_interp
*mi
= data
;
164 /* As per hack note in mi_interpreter_init, swap in the output
166 gdb_setup_readline ();
168 /* These overwrite some of the initialization done in
169 _intialize_event_loop. */
170 call_readline
= gdb_readline2
;
171 input_handler
= mi_execute_command_input_handler
;
172 add_file_handler (input_fd
, stdin_event_handler
, 0);
173 async_command_editing_p
= 0;
174 /* FIXME: This is a total hack for now. PB's use of the MI
175 implicitly relies on a bug in the async support which allows
176 asynchronous commands to leak through the commmand loop. The bug
177 involves (but is not limited to) the fact that sync_execution was
178 erroneously initialized to 0. Duplicate by initializing it thus
182 gdb_stdout
= mi
->out
;
183 /* Route error and log output through the MI. */
184 gdb_stderr
= mi
->err
;
185 gdb_stdlog
= mi
->log
;
186 /* Route target output through the MI. */
187 gdb_stdtarg
= mi
->targ
;
188 /* Route target error through the MI as well. */
189 gdb_stdtargerr
= mi
->targ
;
191 /* Replace all the hooks that we know about. There really needs to
192 be a better way of doing this... */
193 clear_interpreter_hooks ();
195 deprecated_show_load_progress
= mi_load_progress
;
197 /* If we're _the_ interpreter, take control. */
198 if (current_interp_named_p (INTERP_MI1
))
199 deprecated_command_loop_hook
= mi1_command_loop
;
200 else if (current_interp_named_p (INTERP_MI2
))
201 deprecated_command_loop_hook
= mi2_command_loop
;
202 else if (current_interp_named_p (INTERP_MI3
))
203 deprecated_command_loop_hook
= mi3_command_loop
;
205 deprecated_command_loop_hook
= mi2_command_loop
;
211 mi_interpreter_suspend (void *data
)
213 gdb_disable_readline ();
217 static struct gdb_exception
218 mi_interpreter_exec (void *data
, const char *command
)
220 char *tmp
= alloca (strlen (command
) + 1);
222 strcpy (tmp
, command
);
223 mi_execute_command_wrapper (tmp
);
224 return exception_none
;
227 /* Never display the default GDB prompt in MI case. */
230 mi_interpreter_prompt_p (void *data
)
236 mi_cmd_interpreter_exec (char *command
, char **argv
, int argc
)
238 struct interp
*interp_to_use
;
240 char *mi_error_message
= NULL
;
241 struct cleanup
*old_chain
;
244 error (_("-interpreter-exec: "
245 "Usage: -interpreter-exec interp command"));
247 interp_to_use
= interp_lookup (argv
[0]);
248 if (interp_to_use
== NULL
)
249 error (_("-interpreter-exec: could not find interpreter \"%s\""),
252 if (!interp_exec_p (interp_to_use
))
253 error (_("-interpreter-exec: interpreter \"%s\" "
254 "does not support command execution"),
257 /* Insert the MI out hooks, making sure to also call the
258 interpreter's hooks if it has any. */
259 /* KRS: We shouldn't need this... Events should be installed and
260 they should just ALWAYS fire something out down the MI
262 mi_insert_notify_hooks ();
264 /* Now run the code. */
266 old_chain
= make_cleanup (null_cleanup
, 0);
267 for (i
= 1; i
< argc
; i
++)
269 struct gdb_exception e
= interp_exec (interp_to_use
, argv
[i
]);
273 mi_error_message
= xstrdup (e
.message
);
274 make_cleanup (xfree
, mi_error_message
);
279 mi_remove_notify_hooks ();
281 if (mi_error_message
!= NULL
)
282 error ("%s", mi_error_message
);
283 do_cleanups (old_chain
);
286 /* This inserts a number of hooks that are meant to produce
287 async-notify ("=") MI messages while running commands in another
288 interpreter using mi_interpreter_exec. The canonical use for this
289 is to allow access to the gdb CLI interpreter from within the MI,
290 while still producing MI style output when actions in the CLI
291 command change GDB's state. */
294 mi_insert_notify_hooks (void)
296 deprecated_query_hook
= mi_interp_query_hook
;
300 mi_remove_notify_hooks (void)
302 deprecated_query_hook
= NULL
;
306 mi_interp_query_hook (const char *ctlstr
, va_list ap
)
312 mi_execute_command_wrapper (char *cmd
)
314 mi_execute_command (cmd
, stdin
== instream
);
317 /* mi_execute_command_wrapper wrapper suitable for INPUT_HANDLER. */
320 mi_execute_command_input_handler (char *cmd
)
322 mi_execute_command_wrapper (cmd
);
324 fputs_unfiltered ("(gdb) \n", raw_stdout
);
325 gdb_flush (raw_stdout
);
329 mi1_command_loop (void)
335 mi2_command_loop (void)
341 mi3_command_loop (void)
347 mi_command_loop (int mi_version
)
349 /* Turn off 8 bit strings in quoted output. Any character with the
350 high bit set is printed using C's octal format. */
351 sevenbit_strings
= 1;
353 /* Tell the world that we're alive. */
354 fputs_unfiltered ("(gdb) \n", raw_stdout
);
355 gdb_flush (raw_stdout
);
361 mi_new_thread (struct thread_info
*t
)
363 struct mi_interp
*mi
= top_level_interpreter_data ();
364 struct inferior
*inf
= find_inferior_pid (ptid_get_pid (t
->ptid
));
368 fprintf_unfiltered (mi
->event_channel
,
369 "thread-created,id=\"%d\",group-id=\"i%d\"",
371 gdb_flush (mi
->event_channel
);
375 mi_thread_exit (struct thread_info
*t
, int silent
)
377 struct mi_interp
*mi
;
378 struct inferior
*inf
;
383 inf
= find_inferior_pid (ptid_get_pid (t
->ptid
));
385 mi
= top_level_interpreter_data ();
386 target_terminal_ours ();
387 fprintf_unfiltered (mi
->event_channel
,
388 "thread-exited,id=\"%d\",group-id=\"i%d\"",
390 gdb_flush (mi
->event_channel
);
393 /* Emit notification on changing the state of record. */
396 mi_record_changed (struct inferior
*inferior
, int started
)
398 struct mi_interp
*mi
= top_level_interpreter_data ();
400 fprintf_unfiltered (mi
->event_channel
, "record-%s,thread-group=\"i%d\"",
401 started
? "started" : "stopped", inferior
->num
);
403 gdb_flush (mi
->event_channel
);
407 mi_inferior_added (struct inferior
*inf
)
409 struct mi_interp
*mi
= top_level_interpreter_data ();
411 target_terminal_ours ();
412 fprintf_unfiltered (mi
->event_channel
,
413 "thread-group-added,id=\"i%d\"",
415 gdb_flush (mi
->event_channel
);
419 mi_inferior_appeared (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-started,id=\"i%d\",pid=\"%d\"",
427 gdb_flush (mi
->event_channel
);
431 mi_inferior_exit (struct inferior
*inf
)
433 struct mi_interp
*mi
= top_level_interpreter_data ();
435 target_terminal_ours ();
436 if (inf
->has_exit_code
)
437 fprintf_unfiltered (mi
->event_channel
,
438 "thread-group-exited,id=\"i%d\",exit-code=\"%s\"",
439 inf
->num
, int_string (inf
->exit_code
, 8, 0, 0, 1));
441 fprintf_unfiltered (mi
->event_channel
,
442 "thread-group-exited,id=\"i%d\"", inf
->num
);
444 gdb_flush (mi
->event_channel
);
448 mi_inferior_removed (struct inferior
*inf
)
450 struct mi_interp
*mi
= top_level_interpreter_data ();
452 target_terminal_ours ();
453 fprintf_unfiltered (mi
->event_channel
,
454 "thread-group-removed,id=\"i%d\"",
456 gdb_flush (mi
->event_channel
);
460 mi_on_normal_stop (struct bpstats
*bs
, int print_frame
)
462 /* Since this can be called when CLI command is executing,
463 using cli interpreter, be sure to use MI uiout for output,
464 not the current one. */
465 struct ui_out
*mi_uiout
= interp_ui_out (top_level_interpreter ());
471 if (current_uiout
!= mi_uiout
)
473 /* The normal_stop function has printed frame information
474 into CLI uiout, or some other non-MI uiout. There's no
475 way we can extract proper fields from random uiout
476 object, so we print the frame again. In practice, this
477 can only happen when running a CLI command in MI. */
478 struct ui_out
*saved_uiout
= current_uiout
;
479 struct target_waitstatus last
;
482 current_uiout
= mi_uiout
;
484 get_last_target_status (&last_ptid
, &last
);
485 bpstat_print (bs
, last
.kind
);
487 print_stack_frame (get_selected_frame (NULL
), 0, SRC_AND_LOC
);
488 current_uiout
= saved_uiout
;
491 ui_out_field_int (mi_uiout
, "thread-id",
492 pid_to_thread_id (inferior_ptid
));
495 struct cleanup
*back_to
= make_cleanup_ui_out_list_begin_end
496 (mi_uiout
, "stopped-threads");
498 ui_out_field_int (mi_uiout
, NULL
,
499 pid_to_thread_id (inferior_ptid
));
500 do_cleanups (back_to
);
503 ui_out_field_string (mi_uiout
, "stopped-threads", "all");
505 core
= target_core_of_thread (inferior_ptid
);
507 ui_out_field_int (mi_uiout
, "core", core
);
510 fputs_unfiltered ("*stopped", raw_stdout
);
511 mi_out_put (mi_uiout
, raw_stdout
);
512 mi_out_rewind (mi_uiout
);
513 mi_print_timing_maybe ();
514 fputs_unfiltered ("\n", raw_stdout
);
515 gdb_flush (raw_stdout
);
519 mi_about_to_proceed (void)
521 /* Suppress output while calling an inferior function. */
523 if (!ptid_equal (inferior_ptid
, null_ptid
))
525 struct thread_info
*tp
= inferior_thread ();
527 if (tp
->control
.in_infcall
)
534 /* When the element is non-zero, no MI notifications will be emitted in
535 response to the corresponding observers. */
537 struct mi_suppress_notification mi_suppress_notification
=
544 /* Emit notification on changing a traceframe. */
547 mi_traceframe_changed (int tfnum
, int tpnum
)
549 struct mi_interp
*mi
= top_level_interpreter_data ();
551 if (mi_suppress_notification
.traceframe
)
554 target_terminal_ours ();
557 fprintf_unfiltered (mi
->event_channel
, "traceframe-changed,"
558 "num=\"%d\",tracepoint=\"%d\"\n",
561 fprintf_unfiltered (mi
->event_channel
, "traceframe-changed,end");
563 gdb_flush (mi
->event_channel
);
566 /* Emit notification on creating a trace state variable. */
569 mi_tsv_created (const struct trace_state_variable
*tsv
)
571 struct mi_interp
*mi
= top_level_interpreter_data ();
573 target_terminal_ours ();
575 fprintf_unfiltered (mi
->event_channel
, "tsv-created,"
576 "name=\"%s\",initial=\"%s\"\n",
577 tsv
->name
, plongest (tsv
->initial_value
));
579 gdb_flush (mi
->event_channel
);
582 /* Emit notification on deleting a trace state variable. */
585 mi_tsv_deleted (const struct trace_state_variable
*tsv
)
587 struct mi_interp
*mi
= top_level_interpreter_data ();
589 target_terminal_ours ();
592 fprintf_unfiltered (mi
->event_channel
, "tsv-deleted,"
593 "name=\"%s\"\n", tsv
->name
);
595 fprintf_unfiltered (mi
->event_channel
, "tsv-deleted\n");
597 gdb_flush (mi
->event_channel
);
600 /* Emit notification on modifying a trace state variable. */
603 mi_tsv_modified (const struct trace_state_variable
*tsv
)
605 struct mi_interp
*mi
= top_level_interpreter_data ();
606 struct ui_out
*mi_uiout
= interp_ui_out (top_level_interpreter ());
608 target_terminal_ours ();
610 fprintf_unfiltered (mi
->event_channel
,
613 ui_out_redirect (mi_uiout
, mi
->event_channel
);
615 ui_out_field_string (mi_uiout
, "name", tsv
->name
);
616 ui_out_field_string (mi_uiout
, "initial",
617 plongest (tsv
->initial_value
));
618 if (tsv
->value_known
)
619 ui_out_field_string (mi_uiout
, "current", plongest (tsv
->value
));
621 ui_out_redirect (mi_uiout
, NULL
);
623 gdb_flush (mi
->event_channel
);
626 /* Emit notification about a created breakpoint. */
629 mi_breakpoint_created (struct breakpoint
*b
)
631 struct mi_interp
*mi
= top_level_interpreter_data ();
632 struct ui_out
*mi_uiout
= interp_ui_out (top_level_interpreter ());
633 volatile struct gdb_exception e
;
635 if (mi_suppress_notification
.breakpoint
)
641 target_terminal_ours ();
642 fprintf_unfiltered (mi
->event_channel
,
643 "breakpoint-created");
644 /* We want the output from gdb_breakpoint_query to go to
645 mi->event_channel. One approach would be to just call
646 gdb_breakpoint_query, and then use mi_out_put to send the current
647 content of mi_outout into mi->event_channel. However, that will
648 break if anything is output to mi_uiout prior to calling the
649 breakpoint_created notifications. So, we use
651 ui_out_redirect (mi_uiout
, mi
->event_channel
);
652 TRY_CATCH (e
, RETURN_MASK_ERROR
)
653 gdb_breakpoint_query (mi_uiout
, b
->number
, NULL
);
654 ui_out_redirect (mi_uiout
, NULL
);
656 gdb_flush (mi
->event_channel
);
659 /* Emit notification about deleted breakpoint. */
662 mi_breakpoint_deleted (struct breakpoint
*b
)
664 struct mi_interp
*mi
= top_level_interpreter_data ();
666 if (mi_suppress_notification
.breakpoint
)
672 target_terminal_ours ();
674 fprintf_unfiltered (mi
->event_channel
, "breakpoint-deleted,id=\"%d\"",
677 gdb_flush (mi
->event_channel
);
680 /* Emit notification about modified breakpoint. */
683 mi_breakpoint_modified (struct breakpoint
*b
)
685 struct mi_interp
*mi
= top_level_interpreter_data ();
686 struct ui_out
*mi_uiout
= interp_ui_out (top_level_interpreter ());
687 volatile struct gdb_exception e
;
689 if (mi_suppress_notification
.breakpoint
)
695 target_terminal_ours ();
696 fprintf_unfiltered (mi
->event_channel
,
697 "breakpoint-modified");
698 /* We want the output from gdb_breakpoint_query to go to
699 mi->event_channel. One approach would be to just call
700 gdb_breakpoint_query, and then use mi_out_put to send the current
701 content of mi_outout into mi->event_channel. However, that will
702 break if anything is output to mi_uiout prior to calling the
703 breakpoint_created notifications. So, we use
705 ui_out_redirect (mi_uiout
, mi
->event_channel
);
706 TRY_CATCH (e
, RETURN_MASK_ERROR
)
707 gdb_breakpoint_query (mi_uiout
, b
->number
, NULL
);
708 ui_out_redirect (mi_uiout
, NULL
);
710 gdb_flush (mi
->event_channel
);
714 mi_output_running_pid (struct thread_info
*info
, void *arg
)
718 if (ptid_get_pid (*ptid
) == ptid_get_pid (info
->ptid
))
719 fprintf_unfiltered (raw_stdout
,
720 "*running,thread-id=\"%d\"\n",
727 mi_inferior_count (struct inferior
*inf
, void *arg
)
739 mi_on_resume (ptid_t ptid
)
741 struct thread_info
*tp
= NULL
;
743 if (ptid_equal (ptid
, minus_one_ptid
) || ptid_is_pid (ptid
))
744 tp
= inferior_thread ();
746 tp
= find_thread_ptid (ptid
);
748 /* Suppress output while calling an inferior function. */
749 if (tp
->control
.in_infcall
)
752 /* To cater for older frontends, emit ^running, but do it only once
753 per each command. We do it here, since at this point we know
754 that the target was successfully resumed, and in non-async mode,
755 we won't return back to MI interpreter code until the target
756 is done running, so delaying the output of "^running" until then
757 will make it impossible for frontend to know what's going on.
759 In future (MI3), we'll be outputting "^done" here. */
760 if (!running_result_record_printed
&& mi_proceeded
)
762 fprintf_unfiltered (raw_stdout
, "%s^running\n",
763 current_token
? current_token
: "");
766 if (PIDGET (ptid
) == -1)
767 fprintf_unfiltered (raw_stdout
, "*running,thread-id=\"all\"\n");
768 else if (ptid_is_pid (ptid
))
772 /* Backwards compatibility. If there's only one inferior,
773 output "all", otherwise, output each resumed thread
775 iterate_over_inferiors (mi_inferior_count
, &count
);
778 fprintf_unfiltered (raw_stdout
, "*running,thread-id=\"all\"\n");
780 iterate_over_threads (mi_output_running_pid
, &ptid
);
784 struct thread_info
*ti
= find_thread_ptid (ptid
);
787 fprintf_unfiltered (raw_stdout
, "*running,thread-id=\"%d\"\n", ti
->num
);
790 if (!running_result_record_printed
&& mi_proceeded
)
792 running_result_record_printed
= 1;
793 /* This is what gdb used to do historically -- printing prompt even if
794 it cannot actually accept any input. This will be surely removed
795 for MI3, and may be removed even earler. */
796 /* FIXME: review the use of target_is_async_p here -- is that
798 if (!target_is_async_p ())
799 fputs_unfiltered ("(gdb) \n", raw_stdout
);
801 gdb_flush (raw_stdout
);
805 mi_solib_loaded (struct so_list
*solib
)
807 struct mi_interp
*mi
= top_level_interpreter_data ();
809 target_terminal_ours ();
810 if (gdbarch_has_global_solist (target_gdbarch ()))
811 fprintf_unfiltered (mi
->event_channel
,
812 "library-loaded,id=\"%s\",target-name=\"%s\","
813 "host-name=\"%s\",symbols-loaded=\"%d\"",
814 solib
->so_original_name
, solib
->so_original_name
,
815 solib
->so_name
, solib
->symbols_loaded
);
817 fprintf_unfiltered (mi
->event_channel
,
818 "library-loaded,id=\"%s\",target-name=\"%s\","
819 "host-name=\"%s\",symbols-loaded=\"%d\","
820 "thread-group=\"i%d\"",
821 solib
->so_original_name
, solib
->so_original_name
,
822 solib
->so_name
, solib
->symbols_loaded
,
823 current_inferior ()->num
);
825 gdb_flush (mi
->event_channel
);
829 mi_solib_unloaded (struct so_list
*solib
)
831 struct mi_interp
*mi
= top_level_interpreter_data ();
833 target_terminal_ours ();
834 if (gdbarch_has_global_solist (target_gdbarch ()))
835 fprintf_unfiltered (mi
->event_channel
,
836 "library-unloaded,id=\"%s\",target-name=\"%s\","
838 solib
->so_original_name
, solib
->so_original_name
,
841 fprintf_unfiltered (mi
->event_channel
,
842 "library-unloaded,id=\"%s\",target-name=\"%s\","
843 "host-name=\"%s\",thread-group=\"i%d\"",
844 solib
->so_original_name
, solib
->so_original_name
,
845 solib
->so_name
, current_inferior ()->num
);
847 gdb_flush (mi
->event_channel
);
850 /* Emit notification about the command parameter change. */
853 mi_command_param_changed (const char *param
, const char *value
)
855 struct mi_interp
*mi
= top_level_interpreter_data ();
856 struct ui_out
*mi_uiout
= interp_ui_out (top_level_interpreter ());
858 if (mi_suppress_notification
.cmd_param_changed
)
861 target_terminal_ours ();
863 fprintf_unfiltered (mi
->event_channel
,
864 "cmd-param-changed");
866 ui_out_redirect (mi_uiout
, mi
->event_channel
);
868 ui_out_field_string (mi_uiout
, "param", param
);
869 ui_out_field_string (mi_uiout
, "value", value
);
871 ui_out_redirect (mi_uiout
, NULL
);
873 gdb_flush (mi
->event_channel
);
876 /* Emit notification about the target memory change. */
879 mi_memory_changed (struct inferior
*inferior
, CORE_ADDR memaddr
,
880 ssize_t len
, const bfd_byte
*myaddr
)
882 struct mi_interp
*mi
= top_level_interpreter_data ();
883 struct ui_out
*mi_uiout
= interp_ui_out (top_level_interpreter ());
884 struct obj_section
*sec
;
886 if (mi_suppress_notification
.memory
)
889 target_terminal_ours ();
891 fprintf_unfiltered (mi
->event_channel
,
894 ui_out_redirect (mi_uiout
, mi
->event_channel
);
896 ui_out_field_fmt (mi_uiout
, "thread-group", "i%d", inferior
->num
);
897 ui_out_field_core_addr (mi_uiout
, "addr", target_gdbarch (), memaddr
);
898 ui_out_field_fmt (mi_uiout
, "len", "0x%zx", len
);
900 /* Append 'type=code' into notification if MEMADDR falls in the range of
901 sections contain code. */
902 sec
= find_pc_section (memaddr
);
903 if (sec
!= NULL
&& sec
->objfile
!= NULL
)
905 flagword flags
= bfd_get_section_flags (sec
->objfile
->obfd
,
906 sec
->the_bfd_section
);
908 if (flags
& SEC_CODE
)
909 ui_out_field_string (mi_uiout
, "type", "code");
912 ui_out_redirect (mi_uiout
, NULL
);
914 gdb_flush (mi
->event_channel
);
918 report_initial_inferior (struct inferior
*inf
, void *closure
)
920 /* This function is called from mi_intepreter_init, and since
921 mi_inferior_added assumes that inferior is fully initialized
922 and top_level_interpreter_data is set, we cannot call
924 struct mi_interp
*mi
= closure
;
926 target_terminal_ours ();
927 fprintf_unfiltered (mi
->event_channel
,
928 "thread-group-added,id=\"i%d\"",
930 gdb_flush (mi
->event_channel
);
934 static struct ui_out
*
935 mi_ui_out (struct interp
*interp
)
937 struct mi_interp
*mi
= interp_data (interp
);
942 /* Save the original value of raw_stdout here when logging, so we can
943 restore correctly when done. */
945 static struct ui_file
*saved_raw_stdout
;
947 /* Do MI-specific logging actions; save raw_stdout, and change all
948 the consoles to use the supplied ui-file(s). */
951 mi_set_logging (struct interp
*interp
, int start_log
,
952 struct ui_file
*out
, struct ui_file
*logfile
)
954 struct mi_interp
*mi
= interp_data (interp
);
961 /* The tee created already is based on gdb_stdout, which for MI
962 is a console and so we end up in an infinite loop of console
963 writing to ui_file writing to console etc. So discard the
964 existing tee (it hasn't been used yet, and MI won't ever use
965 it), and create one based on raw_stdout instead. */
968 ui_file_delete (out
);
969 out
= tee_file_new (raw_stdout
, 0, logfile
, 0);
972 saved_raw_stdout
= raw_stdout
;
977 raw_stdout
= saved_raw_stdout
;
978 saved_raw_stdout
= NULL
;
981 mi_console_set_raw (mi
->out
, raw_stdout
);
982 mi_console_set_raw (mi
->err
, raw_stdout
);
983 mi_console_set_raw (mi
->log
, raw_stdout
);
984 mi_console_set_raw (mi
->targ
, raw_stdout
);
985 mi_console_set_raw (mi
->event_channel
, raw_stdout
);
990 extern initialize_file_ftype _initialize_mi_interp
; /* -Wmissing-prototypes */
993 _initialize_mi_interp (void)
995 static const struct interp_procs procs
=
997 mi_interpreter_init
, /* init_proc */
998 mi_interpreter_resume
, /* resume_proc */
999 mi_interpreter_suspend
, /* suspend_proc */
1000 mi_interpreter_exec
, /* exec_proc */
1001 mi_interpreter_prompt_p
, /* prompt_proc_p */
1002 mi_ui_out
, /* ui_out_proc */
1003 mi_set_logging
/* set_logging_proc */
1006 /* The various interpreter levels. */
1007 interp_add (interp_new (INTERP_MI1
, &procs
));
1008 interp_add (interp_new (INTERP_MI2
, &procs
));
1009 interp_add (interp_new (INTERP_MI3
, &procs
));
1010 interp_add (interp_new (INTERP_MI
, &procs
));