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"
40 /* These are the interpreter setup, etc. functions for the MI
43 static void mi_execute_command_wrapper (char *cmd
);
44 static void mi_execute_command_input_handler (char *cmd
);
45 static void mi_command_loop (int mi_version
);
47 /* These are hooks that we put in place while doing interpreter_exec
48 so we can report interesting things that happened "behind the MI's
49 back" in this command. */
51 static int mi_interp_query_hook (const char *ctlstr
, va_list ap
)
52 ATTRIBUTE_PRINTF (1, 0);
54 static void mi3_command_loop (void);
55 static void mi2_command_loop (void);
56 static void mi1_command_loop (void);
58 static void mi_insert_notify_hooks (void);
59 static void mi_remove_notify_hooks (void);
60 static void mi_on_normal_stop (struct bpstats
*bs
, int print_frame
);
62 static void mi_new_thread (struct thread_info
*t
);
63 static void mi_thread_exit (struct thread_info
*t
, int silent
);
64 static void mi_record_changed (struct inferior
*, int);
65 static void mi_inferior_added (struct inferior
*inf
);
66 static void mi_inferior_appeared (struct inferior
*inf
);
67 static void mi_inferior_exit (struct inferior
*inf
);
68 static void mi_inferior_removed (struct inferior
*inf
);
69 static void mi_on_resume (ptid_t ptid
);
70 static void mi_solib_loaded (struct so_list
*solib
);
71 static void mi_solib_unloaded (struct so_list
*solib
);
72 static void mi_about_to_proceed (void);
73 static void mi_traceframe_changed (int tfnum
, int tpnum
);
74 static void mi_tsv_created (const char *name
, LONGEST value
);
75 static void mi_tsv_deleted (const char *name
);
76 static void mi_breakpoint_created (struct breakpoint
*b
);
77 static void mi_breakpoint_deleted (struct breakpoint
*b
);
78 static void mi_breakpoint_modified (struct breakpoint
*b
);
79 static void mi_command_param_changed (const char *param
, const char *value
);
80 static void mi_memory_changed (struct inferior
*inf
, CORE_ADDR memaddr
,
81 ssize_t len
, const bfd_byte
*myaddr
);
83 static int report_initial_inferior (struct inferior
*inf
, void *closure
);
86 mi_interpreter_init (struct interp
*interp
, int top_level
)
88 struct mi_interp
*mi
= XMALLOC (struct mi_interp
);
92 /* Assign the output channel created at startup to its own global,
93 so that we can create a console channel that encapsulates and
94 prefixes all gdb_output-type bits coming from the rest of the
97 raw_stdout
= gdb_stdout
;
99 /* Create MI console channels, each with a different prefix so they
100 can be distinguished. */
101 mi
->out
= mi_console_file_new (raw_stdout
, "~", '"');
102 mi
->err
= mi_console_file_new (raw_stdout
, "&", '"');
104 mi
->targ
= mi_console_file_new (raw_stdout
, "@", '"');
105 mi
->event_channel
= mi_console_file_new (raw_stdout
, "=", 0);
107 name
= interp_name (interp
);
108 /* INTERP_MI selects the most recent released version. "mi2" was
109 released as part of GDB 6.0. */
110 if (strcmp (name
, INTERP_MI
) == 0)
112 else if (strcmp (name
, INTERP_MI1
) == 0)
114 else if (strcmp (name
, INTERP_MI2
) == 0)
116 else if (strcmp (name
, INTERP_MI3
) == 0)
119 gdb_assert_not_reached ("unhandled MI version");
121 mi
->uiout
= mi_out_new (mi_version
);
125 observer_attach_new_thread (mi_new_thread
);
126 observer_attach_thread_exit (mi_thread_exit
);
127 observer_attach_inferior_added (mi_inferior_added
);
128 observer_attach_inferior_appeared (mi_inferior_appeared
);
129 observer_attach_inferior_exit (mi_inferior_exit
);
130 observer_attach_inferior_removed (mi_inferior_removed
);
131 observer_attach_record_changed (mi_record_changed
);
132 observer_attach_normal_stop (mi_on_normal_stop
);
133 observer_attach_target_resumed (mi_on_resume
);
134 observer_attach_solib_loaded (mi_solib_loaded
);
135 observer_attach_solib_unloaded (mi_solib_unloaded
);
136 observer_attach_about_to_proceed (mi_about_to_proceed
);
137 observer_attach_traceframe_changed (mi_traceframe_changed
);
138 observer_attach_tsv_created (mi_tsv_created
);
139 observer_attach_tsv_deleted (mi_tsv_deleted
);
140 observer_attach_breakpoint_created (mi_breakpoint_created
);
141 observer_attach_breakpoint_deleted (mi_breakpoint_deleted
);
142 observer_attach_breakpoint_modified (mi_breakpoint_modified
);
143 observer_attach_command_param_changed (mi_command_param_changed
);
144 observer_attach_memory_changed (mi_memory_changed
);
146 /* The initial inferior is created before this function is
147 called, so we need to report it explicitly. Use iteration in
148 case future version of GDB creates more than one inferior
150 iterate_over_inferiors (report_initial_inferior
, mi
);
157 mi_interpreter_resume (void *data
)
159 struct mi_interp
*mi
= data
;
161 /* As per hack note in mi_interpreter_init, swap in the output
163 gdb_setup_readline ();
165 /* These overwrite some of the initialization done in
166 _intialize_event_loop. */
167 call_readline
= gdb_readline2
;
168 input_handler
= mi_execute_command_input_handler
;
169 add_file_handler (input_fd
, stdin_event_handler
, 0);
170 async_command_editing_p
= 0;
171 /* FIXME: This is a total hack for now. PB's use of the MI
172 implicitly relies on a bug in the async support which allows
173 asynchronous commands to leak through the commmand loop. The bug
174 involves (but is not limited to) the fact that sync_execution was
175 erroneously initialized to 0. Duplicate by initializing it thus
179 gdb_stdout
= mi
->out
;
180 /* Route error and log output through the MI. */
181 gdb_stderr
= mi
->err
;
182 gdb_stdlog
= mi
->log
;
183 /* Route target output through the MI. */
184 gdb_stdtarg
= mi
->targ
;
185 /* Route target error through the MI as well. */
186 gdb_stdtargerr
= mi
->targ
;
188 /* Replace all the hooks that we know about. There really needs to
189 be a better way of doing this... */
190 clear_interpreter_hooks ();
192 deprecated_show_load_progress
= mi_load_progress
;
194 /* If we're _the_ interpreter, take control. */
195 if (current_interp_named_p (INTERP_MI1
))
196 deprecated_command_loop_hook
= mi1_command_loop
;
197 else if (current_interp_named_p (INTERP_MI2
))
198 deprecated_command_loop_hook
= mi2_command_loop
;
199 else if (current_interp_named_p (INTERP_MI3
))
200 deprecated_command_loop_hook
= mi3_command_loop
;
202 deprecated_command_loop_hook
= mi2_command_loop
;
208 mi_interpreter_suspend (void *data
)
210 gdb_disable_readline ();
214 static struct gdb_exception
215 mi_interpreter_exec (void *data
, const char *command
)
217 char *tmp
= alloca (strlen (command
) + 1);
219 strcpy (tmp
, command
);
220 mi_execute_command_wrapper (tmp
);
221 return exception_none
;
224 /* Never display the default GDB prompt in MI case. */
227 mi_interpreter_prompt_p (void *data
)
233 mi_cmd_interpreter_exec (char *command
, char **argv
, int argc
)
235 struct interp
*interp_to_use
;
237 char *mi_error_message
= NULL
;
238 struct cleanup
*old_chain
;
241 error (_("-interpreter-exec: "
242 "Usage: -interpreter-exec interp command"));
244 interp_to_use
= interp_lookup (argv
[0]);
245 if (interp_to_use
== NULL
)
246 error (_("-interpreter-exec: could not find interpreter \"%s\""),
249 if (!interp_exec_p (interp_to_use
))
250 error (_("-interpreter-exec: interpreter \"%s\" "
251 "does not support command execution"),
254 /* Insert the MI out hooks, making sure to also call the
255 interpreter's hooks if it has any. */
256 /* KRS: We shouldn't need this... Events should be installed and
257 they should just ALWAYS fire something out down the MI
259 mi_insert_notify_hooks ();
261 /* Now run the code. */
263 old_chain
= make_cleanup (null_cleanup
, 0);
264 for (i
= 1; i
< argc
; i
++)
266 struct gdb_exception e
= interp_exec (interp_to_use
, argv
[i
]);
270 mi_error_message
= xstrdup (e
.message
);
271 make_cleanup (xfree
, mi_error_message
);
276 mi_remove_notify_hooks ();
278 if (mi_error_message
!= NULL
)
279 error ("%s", mi_error_message
);
280 do_cleanups (old_chain
);
283 /* This inserts a number of hooks that are meant to produce
284 async-notify ("=") MI messages while running commands in another
285 interpreter using mi_interpreter_exec. The canonical use for this
286 is to allow access to the gdb CLI interpreter from within the MI,
287 while still producing MI style output when actions in the CLI
288 command change GDB's state. */
291 mi_insert_notify_hooks (void)
293 deprecated_query_hook
= mi_interp_query_hook
;
297 mi_remove_notify_hooks (void)
299 deprecated_query_hook
= NULL
;
303 mi_interp_query_hook (const char *ctlstr
, va_list ap
)
309 mi_execute_command_wrapper (char *cmd
)
311 mi_execute_command (cmd
, stdin
== instream
);
314 /* mi_execute_command_wrapper wrapper suitable for INPUT_HANDLER. */
317 mi_execute_command_input_handler (char *cmd
)
319 mi_execute_command_wrapper (cmd
);
321 fputs_unfiltered ("(gdb) \n", raw_stdout
);
322 gdb_flush (raw_stdout
);
326 mi1_command_loop (void)
332 mi2_command_loop (void)
338 mi3_command_loop (void)
344 mi_command_loop (int mi_version
)
346 /* Turn off 8 bit strings in quoted output. Any character with the
347 high bit set is printed using C's octal format. */
348 sevenbit_strings
= 1;
350 /* Tell the world that we're alive. */
351 fputs_unfiltered ("(gdb) \n", raw_stdout
);
352 gdb_flush (raw_stdout
);
358 mi_new_thread (struct thread_info
*t
)
360 struct mi_interp
*mi
= top_level_interpreter_data ();
361 struct inferior
*inf
= find_inferior_pid (ptid_get_pid (t
->ptid
));
365 fprintf_unfiltered (mi
->event_channel
,
366 "thread-created,id=\"%d\",group-id=\"i%d\"",
368 gdb_flush (mi
->event_channel
);
372 mi_thread_exit (struct thread_info
*t
, int silent
)
374 struct mi_interp
*mi
;
375 struct inferior
*inf
;
380 inf
= find_inferior_pid (ptid_get_pid (t
->ptid
));
382 mi
= top_level_interpreter_data ();
383 target_terminal_ours ();
384 fprintf_unfiltered (mi
->event_channel
,
385 "thread-exited,id=\"%d\",group-id=\"i%d\"",
387 gdb_flush (mi
->event_channel
);
390 /* Emit notification on changing the state of record. */
393 mi_record_changed (struct inferior
*inferior
, int started
)
395 struct mi_interp
*mi
= top_level_interpreter_data ();
397 fprintf_unfiltered (mi
->event_channel
, "record-%s,thread-group=\"i%d\"",
398 started
? "started" : "stopped", inferior
->num
);
400 gdb_flush (mi
->event_channel
);
404 mi_inferior_added (struct inferior
*inf
)
406 struct mi_interp
*mi
= top_level_interpreter_data ();
408 target_terminal_ours ();
409 fprintf_unfiltered (mi
->event_channel
,
410 "thread-group-added,id=\"i%d\"",
412 gdb_flush (mi
->event_channel
);
416 mi_inferior_appeared (struct inferior
*inf
)
418 struct mi_interp
*mi
= top_level_interpreter_data ();
420 target_terminal_ours ();
421 fprintf_unfiltered (mi
->event_channel
,
422 "thread-group-started,id=\"i%d\",pid=\"%d\"",
424 gdb_flush (mi
->event_channel
);
428 mi_inferior_exit (struct inferior
*inf
)
430 struct mi_interp
*mi
= top_level_interpreter_data ();
432 target_terminal_ours ();
433 if (inf
->has_exit_code
)
434 fprintf_unfiltered (mi
->event_channel
,
435 "thread-group-exited,id=\"i%d\",exit-code=\"%s\"",
436 inf
->num
, int_string (inf
->exit_code
, 8, 0, 0, 1));
438 fprintf_unfiltered (mi
->event_channel
,
439 "thread-group-exited,id=\"i%d\"", inf
->num
);
441 gdb_flush (mi
->event_channel
);
445 mi_inferior_removed (struct inferior
*inf
)
447 struct mi_interp
*mi
= top_level_interpreter_data ();
449 target_terminal_ours ();
450 fprintf_unfiltered (mi
->event_channel
,
451 "thread-group-removed,id=\"i%d\"",
453 gdb_flush (mi
->event_channel
);
457 mi_on_normal_stop (struct bpstats
*bs
, int print_frame
)
459 /* Since this can be called when CLI command is executing,
460 using cli interpreter, be sure to use MI uiout for output,
461 not the current one. */
462 struct ui_out
*mi_uiout
= interp_ui_out (top_level_interpreter ());
468 if (current_uiout
!= mi_uiout
)
470 /* The normal_stop function has printed frame information
471 into CLI uiout, or some other non-MI uiout. There's no
472 way we can extract proper fields from random uiout
473 object, so we print the frame again. In practice, this
474 can only happen when running a CLI command in MI. */
475 struct ui_out
*saved_uiout
= current_uiout
;
476 struct target_waitstatus last
;
479 current_uiout
= mi_uiout
;
481 get_last_target_status (&last_ptid
, &last
);
482 bpstat_print (bs
, last
.kind
);
484 print_stack_frame (get_selected_frame (NULL
), 0, SRC_AND_LOC
);
485 current_uiout
= saved_uiout
;
488 ui_out_field_int (mi_uiout
, "thread-id",
489 pid_to_thread_id (inferior_ptid
));
492 struct cleanup
*back_to
= make_cleanup_ui_out_list_begin_end
493 (mi_uiout
, "stopped-threads");
495 ui_out_field_int (mi_uiout
, NULL
,
496 pid_to_thread_id (inferior_ptid
));
497 do_cleanups (back_to
);
500 ui_out_field_string (mi_uiout
, "stopped-threads", "all");
502 core
= target_core_of_thread (inferior_ptid
);
504 ui_out_field_int (mi_uiout
, "core", core
);
507 fputs_unfiltered ("*stopped", raw_stdout
);
508 mi_out_put (mi_uiout
, raw_stdout
);
509 mi_out_rewind (mi_uiout
);
510 mi_print_timing_maybe ();
511 fputs_unfiltered ("\n", raw_stdout
);
512 gdb_flush (raw_stdout
);
516 mi_about_to_proceed (void)
518 /* Suppress output while calling an inferior function. */
520 if (!ptid_equal (inferior_ptid
, null_ptid
))
522 struct thread_info
*tp
= inferior_thread ();
524 if (tp
->control
.in_infcall
)
531 /* When the element is non-zero, no MI notifications will be emitted in
532 response to the corresponding observers. */
534 struct mi_suppress_notification mi_suppress_notification
=
541 /* Emit notification on changing a traceframe. */
544 mi_traceframe_changed (int tfnum
, int tpnum
)
546 struct mi_interp
*mi
= top_level_interpreter_data ();
548 if (mi_suppress_notification
.traceframe
)
551 target_terminal_ours ();
554 fprintf_unfiltered (mi
->event_channel
, "traceframe-changed,"
555 "num=\"%d\",tracepoint=\"%d\"\n",
558 fprintf_unfiltered (mi
->event_channel
, "traceframe-changed,end");
560 gdb_flush (mi
->event_channel
);
563 /* Emit notification on creating a trace state variable. */
566 mi_tsv_created (const char *name
, LONGEST value
)
568 struct mi_interp
*mi
= top_level_interpreter_data ();
570 target_terminal_ours ();
572 fprintf_unfiltered (mi
->event_channel
, "tsv-created,"
573 "name=\"%s\",value=\"%s\"\n",
574 name
, plongest (value
));
576 gdb_flush (mi
->event_channel
);
579 /* Emit notification on deleting a trace state variable. */
582 mi_tsv_deleted (const char *name
)
584 struct mi_interp
*mi
= top_level_interpreter_data ();
586 target_terminal_ours ();
589 fprintf_unfiltered (mi
->event_channel
, "tsv-deleted,"
590 "name=\"%s\"\n", name
);
592 fprintf_unfiltered (mi
->event_channel
, "tsv-deleted\n");
594 gdb_flush (mi
->event_channel
);
597 /* Emit notification about a created breakpoint. */
600 mi_breakpoint_created (struct breakpoint
*b
)
602 struct mi_interp
*mi
= top_level_interpreter_data ();
603 struct ui_out
*mi_uiout
= interp_ui_out (top_level_interpreter ());
604 volatile struct gdb_exception e
;
606 if (mi_suppress_notification
.breakpoint
)
612 target_terminal_ours ();
613 fprintf_unfiltered (mi
->event_channel
,
614 "breakpoint-created");
615 /* We want the output from gdb_breakpoint_query to go to
616 mi->event_channel. One approach would be to just call
617 gdb_breakpoint_query, and then use mi_out_put to send the current
618 content of mi_outout into mi->event_channel. However, that will
619 break if anything is output to mi_uiout prior to calling the
620 breakpoint_created notifications. So, we use
622 ui_out_redirect (mi_uiout
, mi
->event_channel
);
623 TRY_CATCH (e
, RETURN_MASK_ERROR
)
624 gdb_breakpoint_query (mi_uiout
, b
->number
, NULL
);
625 ui_out_redirect (mi_uiout
, NULL
);
627 gdb_flush (mi
->event_channel
);
630 /* Emit notification about deleted breakpoint. */
633 mi_breakpoint_deleted (struct breakpoint
*b
)
635 struct mi_interp
*mi
= top_level_interpreter_data ();
637 if (mi_suppress_notification
.breakpoint
)
643 target_terminal_ours ();
645 fprintf_unfiltered (mi
->event_channel
, "breakpoint-deleted,id=\"%d\"",
648 gdb_flush (mi
->event_channel
);
651 /* Emit notification about modified breakpoint. */
654 mi_breakpoint_modified (struct breakpoint
*b
)
656 struct mi_interp
*mi
= top_level_interpreter_data ();
657 struct ui_out
*mi_uiout
= interp_ui_out (top_level_interpreter ());
658 volatile struct gdb_exception e
;
660 if (mi_suppress_notification
.breakpoint
)
666 target_terminal_ours ();
667 fprintf_unfiltered (mi
->event_channel
,
668 "breakpoint-modified");
669 /* We want the output from gdb_breakpoint_query to go to
670 mi->event_channel. One approach would be to just call
671 gdb_breakpoint_query, and then use mi_out_put to send the current
672 content of mi_outout into mi->event_channel. However, that will
673 break if anything is output to mi_uiout prior to calling the
674 breakpoint_created notifications. So, we use
676 ui_out_redirect (mi_uiout
, mi
->event_channel
);
677 TRY_CATCH (e
, RETURN_MASK_ERROR
)
678 gdb_breakpoint_query (mi_uiout
, b
->number
, NULL
);
679 ui_out_redirect (mi_uiout
, NULL
);
681 gdb_flush (mi
->event_channel
);
685 mi_output_running_pid (struct thread_info
*info
, void *arg
)
689 if (ptid_get_pid (*ptid
) == ptid_get_pid (info
->ptid
))
690 fprintf_unfiltered (raw_stdout
,
691 "*running,thread-id=\"%d\"\n",
698 mi_inferior_count (struct inferior
*inf
, void *arg
)
710 mi_on_resume (ptid_t ptid
)
712 struct thread_info
*tp
= NULL
;
714 if (ptid_equal (ptid
, minus_one_ptid
) || ptid_is_pid (ptid
))
715 tp
= inferior_thread ();
717 tp
= find_thread_ptid (ptid
);
719 /* Suppress output while calling an inferior function. */
720 if (tp
->control
.in_infcall
)
723 /* To cater for older frontends, emit ^running, but do it only once
724 per each command. We do it here, since at this point we know
725 that the target was successfully resumed, and in non-async mode,
726 we won't return back to MI interpreter code until the target
727 is done running, so delaying the output of "^running" until then
728 will make it impossible for frontend to know what's going on.
730 In future (MI3), we'll be outputting "^done" here. */
731 if (!running_result_record_printed
&& mi_proceeded
)
733 fprintf_unfiltered (raw_stdout
, "%s^running\n",
734 current_token
? current_token
: "");
737 if (PIDGET (ptid
) == -1)
738 fprintf_unfiltered (raw_stdout
, "*running,thread-id=\"all\"\n");
739 else if (ptid_is_pid (ptid
))
743 /* Backwards compatibility. If there's only one inferior,
744 output "all", otherwise, output each resumed thread
746 iterate_over_inferiors (mi_inferior_count
, &count
);
749 fprintf_unfiltered (raw_stdout
, "*running,thread-id=\"all\"\n");
751 iterate_over_threads (mi_output_running_pid
, &ptid
);
755 struct thread_info
*ti
= find_thread_ptid (ptid
);
758 fprintf_unfiltered (raw_stdout
, "*running,thread-id=\"%d\"\n", ti
->num
);
761 if (!running_result_record_printed
&& mi_proceeded
)
763 running_result_record_printed
= 1;
764 /* This is what gdb used to do historically -- printing prompt even if
765 it cannot actually accept any input. This will be surely removed
766 for MI3, and may be removed even earler. */
767 /* FIXME: review the use of target_is_async_p here -- is that
769 if (!target_is_async_p ())
770 fputs_unfiltered ("(gdb) \n", raw_stdout
);
772 gdb_flush (raw_stdout
);
776 mi_solib_loaded (struct so_list
*solib
)
778 struct mi_interp
*mi
= top_level_interpreter_data ();
780 target_terminal_ours ();
781 if (gdbarch_has_global_solist (target_gdbarch
))
782 fprintf_unfiltered (mi
->event_channel
,
783 "library-loaded,id=\"%s\",target-name=\"%s\","
784 "host-name=\"%s\",symbols-loaded=\"%d\"",
785 solib
->so_original_name
, solib
->so_original_name
,
786 solib
->so_name
, solib
->symbols_loaded
);
788 fprintf_unfiltered (mi
->event_channel
,
789 "library-loaded,id=\"%s\",target-name=\"%s\","
790 "host-name=\"%s\",symbols-loaded=\"%d\","
791 "thread-group=\"i%d\"",
792 solib
->so_original_name
, solib
->so_original_name
,
793 solib
->so_name
, solib
->symbols_loaded
,
794 current_inferior ()->num
);
796 gdb_flush (mi
->event_channel
);
800 mi_solib_unloaded (struct so_list
*solib
)
802 struct mi_interp
*mi
= top_level_interpreter_data ();
804 target_terminal_ours ();
805 if (gdbarch_has_global_solist (target_gdbarch
))
806 fprintf_unfiltered (mi
->event_channel
,
807 "library-unloaded,id=\"%s\",target-name=\"%s\","
809 solib
->so_original_name
, solib
->so_original_name
,
812 fprintf_unfiltered (mi
->event_channel
,
813 "library-unloaded,id=\"%s\",target-name=\"%s\","
814 "host-name=\"%s\",thread-group=\"i%d\"",
815 solib
->so_original_name
, solib
->so_original_name
,
816 solib
->so_name
, current_inferior ()->num
);
818 gdb_flush (mi
->event_channel
);
821 /* Emit notification about the command parameter change. */
824 mi_command_param_changed (const char *param
, const char *value
)
826 struct mi_interp
*mi
= top_level_interpreter_data ();
827 struct ui_out
*mi_uiout
= interp_ui_out (top_level_interpreter ());
829 if (mi_suppress_notification
.cmd_param_changed
)
832 target_terminal_ours ();
834 fprintf_unfiltered (mi
->event_channel
,
835 "cmd-param-changed");
837 ui_out_redirect (mi_uiout
, mi
->event_channel
);
839 ui_out_field_string (mi_uiout
, "param", param
);
840 ui_out_field_string (mi_uiout
, "value", value
);
842 ui_out_redirect (mi_uiout
, NULL
);
844 gdb_flush (mi
->event_channel
);
847 /* Emit notification about the target memory change. */
850 mi_memory_changed (struct inferior
*inferior
, CORE_ADDR memaddr
,
851 ssize_t len
, const bfd_byte
*myaddr
)
853 struct mi_interp
*mi
= top_level_interpreter_data ();
854 struct ui_out
*mi_uiout
= interp_ui_out (top_level_interpreter ());
855 struct obj_section
*sec
;
857 if (mi_suppress_notification
.memory
)
860 target_terminal_ours ();
862 fprintf_unfiltered (mi
->event_channel
,
865 ui_out_redirect (mi_uiout
, mi
->event_channel
);
867 ui_out_field_fmt (mi_uiout
, "thread-group", "i%d", inferior
->num
);
868 ui_out_field_core_addr (mi_uiout
, "addr", target_gdbarch
, memaddr
);
869 ui_out_field_fmt (mi_uiout
, "len", "0x%zx", len
);
871 /* Append 'type=code' into notification if MEMADDR falls in the range of
872 sections contain code. */
873 sec
= find_pc_section (memaddr
);
874 if (sec
!= NULL
&& sec
->objfile
!= NULL
)
876 flagword flags
= bfd_get_section_flags (sec
->objfile
->obfd
,
877 sec
->the_bfd_section
);
879 if (flags
& SEC_CODE
)
880 ui_out_field_string (mi_uiout
, "type", "code");
883 ui_out_redirect (mi_uiout
, NULL
);
885 gdb_flush (mi
->event_channel
);
889 report_initial_inferior (struct inferior
*inf
, void *closure
)
891 /* This function is called from mi_intepreter_init, and since
892 mi_inferior_added assumes that inferior is fully initialized
893 and top_level_interpreter_data is set, we cannot call
895 struct mi_interp
*mi
= closure
;
897 target_terminal_ours ();
898 fprintf_unfiltered (mi
->event_channel
,
899 "thread-group-added,id=\"i%d\"",
901 gdb_flush (mi
->event_channel
);
905 static struct ui_out
*
906 mi_ui_out (struct interp
*interp
)
908 struct mi_interp
*mi
= interp_data (interp
);
913 /* Save the original value of raw_stdout here when logging, so we can
914 restore correctly when done. */
916 static struct ui_file
*saved_raw_stdout
;
918 /* Do MI-specific logging actions; save raw_stdout, and change all
919 the consoles to use the supplied ui-file(s). */
922 mi_set_logging (struct interp
*interp
, int start_log
,
923 struct ui_file
*out
, struct ui_file
*logfile
)
925 struct mi_interp
*mi
= interp_data (interp
);
932 /* The tee created already is based on gdb_stdout, which for MI
933 is a console and so we end up in an infinite loop of console
934 writing to ui_file writing to console etc. So discard the
935 existing tee (it hasn't been used yet, and MI won't ever use
936 it), and create one based on raw_stdout instead. */
939 ui_file_delete (out
);
940 out
= tee_file_new (raw_stdout
, 0, logfile
, 0);
943 saved_raw_stdout
= raw_stdout
;
948 raw_stdout
= saved_raw_stdout
;
949 saved_raw_stdout
= NULL
;
952 mi_console_set_raw (mi
->out
, raw_stdout
);
953 mi_console_set_raw (mi
->err
, raw_stdout
);
954 mi_console_set_raw (mi
->log
, raw_stdout
);
955 mi_console_set_raw (mi
->targ
, raw_stdout
);
956 mi_console_set_raw (mi
->event_channel
, raw_stdout
);
961 extern initialize_file_ftype _initialize_mi_interp
; /* -Wmissing-prototypes */
964 _initialize_mi_interp (void)
966 static const struct interp_procs procs
=
968 mi_interpreter_init
, /* init_proc */
969 mi_interpreter_resume
, /* resume_proc */
970 mi_interpreter_suspend
, /* suspend_proc */
971 mi_interpreter_exec
, /* exec_proc */
972 mi_interpreter_prompt_p
, /* prompt_proc_p */
973 mi_ui_out
, /* ui_out_proc */
974 mi_set_logging
/* set_logging_proc */
977 /* The various interpreter levels. */
978 interp_add (interp_new (INTERP_MI1
, &procs
));
979 interp_add (interp_new (INTERP_MI2
, &procs
));
980 interp_add (interp_new (INTERP_MI3
, &procs
));
981 interp_add (interp_new (INTERP_MI
, &procs
));