1 /* MI Interpreter Definitions and Commands for GDB, the GNU debugger.
3 Copyright (C) 2002-2019 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/>. */
22 #include "event-top.h"
23 #include "event-loop.h"
31 #include "mi-console.h"
32 #include "mi-common.h"
33 #include "observable.h"
34 #include "gdbthread.h"
37 #include "tracepoint.h"
39 #include "thread-fsm.h"
40 #include "cli/cli-interp.h"
42 /* These are the interpreter setup, etc. functions for the MI
45 static void mi_execute_command_wrapper (const char *cmd);
46 static void mi_execute_command_input_handler
47 (gdb::unique_xmalloc_ptr<char> &&cmd);
49 /* These are hooks that we put in place while doing interpreter_exec
50 so we can report interesting things that happened "behind the MI's
51 back" in this command. */
53 static int mi_interp_query_hook (const char *ctlstr, va_list ap)
54 ATTRIBUTE_PRINTF (1, 0);
56 static void mi_insert_notify_hooks (void);
57 static void mi_remove_notify_hooks (void);
59 static void mi_on_signal_received (enum gdb_signal siggnal);
60 static void mi_on_end_stepping_range (void);
61 static void mi_on_signal_exited (enum gdb_signal siggnal);
62 static void mi_on_exited (int exitstatus);
63 static void mi_on_normal_stop (struct bpstats *bs, int print_frame);
64 static void mi_on_no_history (void);
66 static void mi_new_thread (struct thread_info *t);
67 static void mi_thread_exit (struct thread_info *t, int silent);
68 static void mi_record_changed (struct inferior*, int, const char *,
70 static void mi_inferior_added (struct inferior *inf);
71 static void mi_inferior_appeared (struct inferior *inf);
72 static void mi_inferior_exit (struct inferior *inf);
73 static void mi_inferior_removed (struct inferior *inf);
74 static void mi_on_resume (ptid_t ptid);
75 static void mi_solib_loaded (struct so_list *solib);
76 static void mi_solib_unloaded (struct so_list *solib);
77 static void mi_about_to_proceed (void);
78 static void mi_traceframe_changed (int tfnum, int tpnum);
79 static void mi_tsv_created (const struct trace_state_variable *tsv);
80 static void mi_tsv_deleted (const struct trace_state_variable *tsv);
81 static void mi_tsv_modified (const struct trace_state_variable *tsv);
82 static void mi_breakpoint_created (struct breakpoint *b);
83 static void mi_breakpoint_deleted (struct breakpoint *b);
84 static void mi_breakpoint_modified (struct breakpoint *b);
85 static void mi_command_param_changed (const char *param, const char *value);
86 static void mi_memory_changed (struct inferior *inf, CORE_ADDR memaddr,
87 ssize_t len, const bfd_byte *myaddr);
88 static void mi_on_sync_execution_done (void);
90 static int report_initial_inferior (struct inferior *inf, void *closure);
92 /* Display the MI prompt. */
95 display_mi_prompt (struct mi_interp *mi)
97 struct ui *ui = current_ui;
99 fputs_unfiltered ("(gdb) \n", mi->raw_stdout);
100 gdb_flush (mi->raw_stdout);
101 ui->prompt_state = PROMPTED;
104 /* Returns the INTERP's data cast as mi_interp if INTERP is an MI, and
105 returns NULL otherwise. */
107 static struct mi_interp *
108 as_mi_interp (struct interp *interp)
110 return dynamic_cast<mi_interp *> (interp);
114 mi_interp::init (bool top_level)
116 mi_interp *mi = this;
118 /* Store the current output channel, so that we can create a console
119 channel that encapsulates and prefixes all gdb_output-type bits
120 coming from the rest of the debugger. */
121 mi->raw_stdout = gdb_stdout;
123 /* Create MI console channels, each with a different prefix so they
124 can be distinguished. */
125 mi->out = new mi_console_file (mi->raw_stdout, "~", '"');
126 mi->err = new mi_console_file (mi->raw_stdout, "&", '"');
128 mi->targ = new mi_console_file (mi->raw_stdout, "@", '"');
129 mi->event_channel = new mi_console_file (mi->raw_stdout, "=", 0);
130 mi->mi_uiout = mi_out_new (name ());
131 gdb_assert (mi->mi_uiout != nullptr);
132 mi->cli_uiout = cli_out_new (mi->out);
136 /* The initial inferior is created before this function is
137 called, so we need to report it explicitly. Use iteration in
138 case future version of GDB creates more than one inferior
140 iterate_over_inferiors (report_initial_inferior, mi);
147 struct mi_interp *mi = this;
148 struct ui *ui = current_ui;
150 /* As per hack note in mi_interpreter_init, swap in the output
152 gdb_setup_readline (0);
154 ui->call_readline = gdb_readline_no_editing_callback;
155 ui->input_handler = mi_execute_command_input_handler;
157 gdb_stdout = mi->out;
158 /* Route error and log output through the MI. */
159 gdb_stderr = mi->err;
160 gdb_stdlog = mi->log;
161 /* Route target output through the MI. */
162 gdb_stdtarg = mi->targ;
163 /* Route target error through the MI as well. */
164 gdb_stdtargerr = mi->targ;
166 /* Replace all the hooks that we know about. There really needs to
167 be a better way of doing this... */
168 clear_interpreter_hooks ();
170 deprecated_show_load_progress = mi_load_progress;
174 mi_interp::suspend ()
176 gdb_disable_readline ();
180 mi_interp::exec (const char *command)
182 mi_execute_command_wrapper (command);
183 return exception_none;
187 mi_cmd_interpreter_exec (const char *command, char **argv, int argc)
189 struct interp *interp_to_use;
193 error (_("-interpreter-exec: "
194 "Usage: -interpreter-exec interp command"));
196 interp_to_use = interp_lookup (current_ui, argv[0]);
197 if (interp_to_use == NULL)
198 error (_("-interpreter-exec: could not find interpreter \"%s\""),
201 /* Note that unlike the CLI version of this command, we don't
202 actually set INTERP_TO_USE as the current interpreter, as we
203 still want gdb_stdout, etc. to point at MI streams. */
205 /* Insert the MI out hooks, making sure to also call the
206 interpreter's hooks if it has any. */
207 /* KRS: We shouldn't need this... Events should be installed and
208 they should just ALWAYS fire something out down the MI
210 mi_insert_notify_hooks ();
212 /* Now run the code. */
214 std::string mi_error_message;
215 for (i = 1; i < argc; i++)
217 struct gdb_exception e = interp_exec (interp_to_use, argv[i]);
221 mi_error_message = e.message;
226 mi_remove_notify_hooks ();
228 if (!mi_error_message.empty ())
229 error ("%s", mi_error_message.c_str ());
232 /* This inserts a number of hooks that are meant to produce
233 async-notify ("=") MI messages while running commands in another
234 interpreter using mi_interpreter_exec. The canonical use for this
235 is to allow access to the gdb CLI interpreter from within the MI,
236 while still producing MI style output when actions in the CLI
237 command change GDB's state. */
240 mi_insert_notify_hooks (void)
242 deprecated_query_hook = mi_interp_query_hook;
246 mi_remove_notify_hooks (void)
248 deprecated_query_hook = NULL;
252 mi_interp_query_hook (const char *ctlstr, va_list ap)
258 mi_execute_command_wrapper (const char *cmd)
260 struct ui *ui = current_ui;
262 mi_execute_command (cmd, ui->instream == ui->stdin_stream);
265 /* Observer for the synchronous_command_done notification. */
268 mi_on_sync_execution_done (void)
270 struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
275 /* If MI is sync, then output the MI prompt now, indicating we're
276 ready for further input. */
278 display_mi_prompt (mi);
281 /* mi_execute_command_wrapper wrapper suitable for INPUT_HANDLER. */
284 mi_execute_command_input_handler (gdb::unique_xmalloc_ptr<char> &&cmd)
286 struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
287 struct ui *ui = current_ui;
289 ui->prompt_state = PROMPT_NEEDED;
291 mi_execute_command_wrapper (cmd.get ());
293 /* Print a prompt, indicating we're ready for further input, unless
294 we just started a synchronous command. In that case, we're about
295 to go back to the event loop and will output the prompt in the
296 'synchronous_command_done' observer when the target next
298 if (ui->prompt_state == PROMPT_NEEDED)
299 display_mi_prompt (mi);
303 mi_interp::pre_command_loop ()
305 struct mi_interp *mi = this;
307 /* Turn off 8 bit strings in quoted output. Any character with the
308 high bit set is printed using C's octal format. */
309 sevenbit_strings = 1;
311 /* Tell the world that we're alive. */
312 display_mi_prompt (mi);
316 mi_new_thread (struct thread_info *t)
318 SWITCH_THRU_ALL_UIS ()
320 struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
325 target_terminal::scoped_restore_terminal_state term_state;
326 target_terminal::ours_for_output ();
328 fprintf_unfiltered (mi->event_channel,
329 "thread-created,id=\"%d\",group-id=\"i%d\"",
330 t->global_num, t->inf->num);
331 gdb_flush (mi->event_channel);
336 mi_thread_exit (struct thread_info *t, int silent)
341 SWITCH_THRU_ALL_UIS ()
343 struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
348 target_terminal::scoped_restore_terminal_state term_state;
349 target_terminal::ours_for_output ();
350 fprintf_unfiltered (mi->event_channel,
351 "thread-exited,id=\"%d\",group-id=\"i%d\"",
352 t->global_num, t->inf->num);
353 gdb_flush (mi->event_channel);
357 /* Emit notification on changing the state of record. */
360 mi_record_changed (struct inferior *inferior, int started, const char *method,
363 SWITCH_THRU_ALL_UIS ()
365 struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
370 target_terminal::scoped_restore_terminal_state term_state;
371 target_terminal::ours_for_output ();
377 fprintf_unfiltered (mi->event_channel,
378 "record-started,thread-group=\"i%d\","
379 "method=\"%s\",format=\"%s\"",
380 inferior->num, method, format);
384 fprintf_unfiltered (mi->event_channel,
385 "record-started,thread-group=\"i%d\","
387 inferior->num, method);
392 fprintf_unfiltered (mi->event_channel,
393 "record-stopped,thread-group=\"i%d\"",
397 gdb_flush (mi->event_channel);
402 mi_inferior_added (struct inferior *inf)
404 SWITCH_THRU_ALL_UIS ()
406 struct interp *interp;
407 struct mi_interp *mi;
409 /* We'll be called once for the initial inferior, before the top
410 level interpreter is set. */
411 interp = top_level_interpreter ();
415 mi = as_mi_interp (interp);
419 target_terminal::scoped_restore_terminal_state term_state;
420 target_terminal::ours_for_output ();
422 fprintf_unfiltered (mi->event_channel,
423 "thread-group-added,id=\"i%d\"",
425 gdb_flush (mi->event_channel);
430 mi_inferior_appeared (struct inferior *inf)
432 SWITCH_THRU_ALL_UIS ()
434 struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
439 target_terminal::scoped_restore_terminal_state term_state;
440 target_terminal::ours_for_output ();
442 fprintf_unfiltered (mi->event_channel,
443 "thread-group-started,id=\"i%d\",pid=\"%d\"",
445 gdb_flush (mi->event_channel);
450 mi_inferior_exit (struct inferior *inf)
452 SWITCH_THRU_ALL_UIS ()
454 struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
459 target_terminal::scoped_restore_terminal_state term_state;
460 target_terminal::ours_for_output ();
462 if (inf->has_exit_code)
463 fprintf_unfiltered (mi->event_channel,
464 "thread-group-exited,id=\"i%d\",exit-code=\"%s\"",
465 inf->num, int_string (inf->exit_code, 8, 0, 0, 1));
467 fprintf_unfiltered (mi->event_channel,
468 "thread-group-exited,id=\"i%d\"", inf->num);
470 gdb_flush (mi->event_channel);
475 mi_inferior_removed (struct inferior *inf)
477 SWITCH_THRU_ALL_UIS ()
479 struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
484 target_terminal::scoped_restore_terminal_state term_state;
485 target_terminal::ours_for_output ();
487 fprintf_unfiltered (mi->event_channel,
488 "thread-group-removed,id=\"i%d\"",
490 gdb_flush (mi->event_channel);
494 /* Return the MI interpreter, if it is active -- either because it's
495 the top-level interpreter or the interpreter executing the current
496 command. Returns NULL if the MI interpreter is not being used. */
498 static struct mi_interp *
499 find_mi_interp (void)
501 struct mi_interp *mi;
503 mi = as_mi_interp (top_level_interpreter ());
507 mi = as_mi_interp (command_interp ());
514 /* Observers for several run control events that print why the
515 inferior has stopped to both the MI event channel and to the MI
516 console. If the MI interpreter is not active, print nothing. */
518 /* Observer for the signal_received notification. */
521 mi_on_signal_received (enum gdb_signal siggnal)
523 SWITCH_THRU_ALL_UIS ()
525 struct mi_interp *mi = find_mi_interp ();
530 print_signal_received_reason (mi->mi_uiout, siggnal);
531 print_signal_received_reason (mi->cli_uiout, siggnal);
535 /* Observer for the end_stepping_range notification. */
538 mi_on_end_stepping_range (void)
540 SWITCH_THRU_ALL_UIS ()
542 struct mi_interp *mi = find_mi_interp ();
547 print_end_stepping_range_reason (mi->mi_uiout);
548 print_end_stepping_range_reason (mi->cli_uiout);
552 /* Observer for the signal_exited notification. */
555 mi_on_signal_exited (enum gdb_signal siggnal)
557 SWITCH_THRU_ALL_UIS ()
559 struct mi_interp *mi = find_mi_interp ();
564 print_signal_exited_reason (mi->mi_uiout, siggnal);
565 print_signal_exited_reason (mi->cli_uiout, siggnal);
569 /* Observer for the exited notification. */
572 mi_on_exited (int exitstatus)
574 SWITCH_THRU_ALL_UIS ()
576 struct mi_interp *mi = find_mi_interp ();
581 print_exited_reason (mi->mi_uiout, exitstatus);
582 print_exited_reason (mi->cli_uiout, exitstatus);
586 /* Observer for the no_history notification. */
589 mi_on_no_history (void)
591 SWITCH_THRU_ALL_UIS ()
593 struct mi_interp *mi = find_mi_interp ();
598 print_no_history_reason (mi->mi_uiout);
599 print_no_history_reason (mi->cli_uiout);
604 mi_on_normal_stop_1 (struct bpstats *bs, int print_frame)
606 /* Since this can be called when CLI command is executing,
607 using cli interpreter, be sure to use MI uiout for output,
608 not the current one. */
609 struct ui_out *mi_uiout = top_level_interpreter ()->interp_ui_out ();
610 struct mi_interp *mi = (struct mi_interp *) top_level_interpreter ();
614 struct thread_info *tp;
616 struct interp *console_interp;
618 tp = inferior_thread ();
620 if (tp->thread_fsm != NULL
621 && tp->thread_fsm->finished_p ())
623 enum async_reply_reason reason;
625 reason = tp->thread_fsm->async_reply_reason ();
626 mi_uiout->field_string ("reason", async_reason_lookup (reason));
628 print_stop_event (mi_uiout);
630 console_interp = interp_lookup (current_ui, INTERP_CONSOLE);
631 if (should_print_stop_to_console (console_interp, tp))
632 print_stop_event (mi->cli_uiout);
634 mi_uiout->field_int ("thread-id", tp->global_num);
637 ui_out_emit_list list_emitter (mi_uiout, "stopped-threads");
639 mi_uiout->field_int (NULL, tp->global_num);
642 mi_uiout->field_string ("stopped-threads", "all");
644 core = target_core_of_thread (tp->ptid);
646 mi_uiout->field_int ("core", core);
649 fputs_unfiltered ("*stopped", mi->raw_stdout);
650 mi_out_put (mi_uiout, mi->raw_stdout);
651 mi_out_rewind (mi_uiout);
652 mi_print_timing_maybe (mi->raw_stdout);
653 fputs_unfiltered ("\n", mi->raw_stdout);
654 gdb_flush (mi->raw_stdout);
658 mi_on_normal_stop (struct bpstats *bs, int print_frame)
660 SWITCH_THRU_ALL_UIS ()
662 if (as_mi_interp (top_level_interpreter ()) == NULL)
665 mi_on_normal_stop_1 (bs, print_frame);
670 mi_about_to_proceed (void)
672 /* Suppress output while calling an inferior function. */
674 if (inferior_ptid != null_ptid)
676 struct thread_info *tp = inferior_thread ();
678 if (tp->control.in_infcall)
685 /* When the element is non-zero, no MI notifications will be emitted in
686 response to the corresponding observers. */
688 struct mi_suppress_notification mi_suppress_notification =
696 /* Emit notification on changing a traceframe. */
699 mi_traceframe_changed (int tfnum, int tpnum)
701 if (mi_suppress_notification.traceframe)
704 SWITCH_THRU_ALL_UIS ()
706 struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
711 target_terminal::scoped_restore_terminal_state term_state;
712 target_terminal::ours_for_output ();
715 fprintf_unfiltered (mi->event_channel, "traceframe-changed,"
716 "num=\"%d\",tracepoint=\"%d\"\n",
719 fprintf_unfiltered (mi->event_channel, "traceframe-changed,end");
721 gdb_flush (mi->event_channel);
725 /* Emit notification on creating a trace state variable. */
728 mi_tsv_created (const struct trace_state_variable *tsv)
730 SWITCH_THRU_ALL_UIS ()
732 struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
737 target_terminal::scoped_restore_terminal_state term_state;
738 target_terminal::ours_for_output ();
740 fprintf_unfiltered (mi->event_channel, "tsv-created,"
741 "name=\"%s\",initial=\"%s\"\n",
742 tsv->name.c_str (), plongest (tsv->initial_value));
744 gdb_flush (mi->event_channel);
748 /* Emit notification on deleting a trace state variable. */
751 mi_tsv_deleted (const struct trace_state_variable *tsv)
753 SWITCH_THRU_ALL_UIS ()
755 struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
760 target_terminal::scoped_restore_terminal_state term_state;
761 target_terminal::ours_for_output ();
764 fprintf_unfiltered (mi->event_channel, "tsv-deleted,"
765 "name=\"%s\"\n", tsv->name.c_str ());
767 fprintf_unfiltered (mi->event_channel, "tsv-deleted\n");
769 gdb_flush (mi->event_channel);
773 /* Emit notification on modifying a trace state variable. */
776 mi_tsv_modified (const struct trace_state_variable *tsv)
778 SWITCH_THRU_ALL_UIS ()
780 struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
781 struct ui_out *mi_uiout;
786 mi_uiout = top_level_interpreter ()->interp_ui_out ();
788 target_terminal::scoped_restore_terminal_state term_state;
789 target_terminal::ours_for_output ();
791 fprintf_unfiltered (mi->event_channel,
794 mi_uiout->redirect (mi->event_channel);
796 mi_uiout->field_string ("name", tsv->name);
797 mi_uiout->field_string ("initial",
798 plongest (tsv->initial_value));
799 if (tsv->value_known)
800 mi_uiout->field_string ("current", plongest (tsv->value));
802 mi_uiout->redirect (NULL);
804 gdb_flush (mi->event_channel);
808 /* Print breakpoint BP on MI's event channel. */
811 mi_print_breakpoint_for_event (struct mi_interp *mi, breakpoint *bp)
813 ui_out *mi_uiout = mi->interp_ui_out ();
815 /* We want the output from print_breakpoint to go to
816 mi->event_channel. One approach would be to just call
817 print_breakpoint, and then use mi_out_put to send the current
818 content of mi_uiout into mi->event_channel. However, that will
819 break if anything is output to mi_uiout prior to calling the
820 breakpoint_created notifications. So, we use
822 mi_uiout->redirect (mi->event_channel);
826 scoped_restore restore_uiout
827 = make_scoped_restore (¤t_uiout, mi_uiout);
829 print_breakpoint (bp);
831 CATCH (ex, RETURN_MASK_ALL)
833 exception_print (gdb_stderr, ex);
837 mi_uiout->redirect (NULL);
840 /* Emit notification about a created breakpoint. */
843 mi_breakpoint_created (struct breakpoint *b)
845 if (mi_suppress_notification.breakpoint)
851 SWITCH_THRU_ALL_UIS ()
853 struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
858 target_terminal::scoped_restore_terminal_state term_state;
859 target_terminal::ours_for_output ();
861 fprintf_unfiltered (mi->event_channel,
862 "breakpoint-created");
863 mi_print_breakpoint_for_event (mi, b);
865 gdb_flush (mi->event_channel);
869 /* Emit notification about deleted breakpoint. */
872 mi_breakpoint_deleted (struct breakpoint *b)
874 if (mi_suppress_notification.breakpoint)
880 SWITCH_THRU_ALL_UIS ()
882 struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
887 target_terminal::scoped_restore_terminal_state term_state;
888 target_terminal::ours_for_output ();
890 fprintf_unfiltered (mi->event_channel, "breakpoint-deleted,id=\"%d\"",
893 gdb_flush (mi->event_channel);
897 /* Emit notification about modified breakpoint. */
900 mi_breakpoint_modified (struct breakpoint *b)
902 if (mi_suppress_notification.breakpoint)
908 SWITCH_THRU_ALL_UIS ()
910 struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
915 target_terminal::scoped_restore_terminal_state term_state;
916 target_terminal::ours_for_output ();
917 fprintf_unfiltered (mi->event_channel,
918 "breakpoint-modified");
919 mi_print_breakpoint_for_event (mi, b);
921 gdb_flush (mi->event_channel);
926 mi_output_running (struct thread_info *thread)
928 SWITCH_THRU_ALL_UIS ()
930 struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
935 fprintf_unfiltered (mi->raw_stdout,
936 "*running,thread-id=\"%d\"\n",
941 /* Return true if there are multiple inferiors loaded. This is used
942 for backwards compatibility -- if there's only one inferior, output
943 "all", otherwise, output each resumed thread individually. */
946 multiple_inferiors_p ()
949 for (inferior *inf ATTRIBUTE_UNUSED : all_non_exited_inferiors ())
960 mi_on_resume_1 (struct mi_interp *mi, ptid_t ptid)
962 /* To cater for older frontends, emit ^running, but do it only once
963 per each command. We do it here, since at this point we know
964 that the target was successfully resumed, and in non-async mode,
965 we won't return back to MI interpreter code until the target
966 is done running, so delaying the output of "^running" until then
967 will make it impossible for frontend to know what's going on.
969 In future (MI3), we'll be outputting "^done" here. */
970 if (!running_result_record_printed && mi_proceeded)
972 fprintf_unfiltered (mi->raw_stdout, "%s^running\n",
973 current_token ? current_token : "");
976 /* Backwards compatibility. If doing a wildcard resume and there's
977 only one inferior, output "all", otherwise, output each resumed
978 thread individually. */
979 if ((ptid == minus_one_ptid || ptid.is_pid ())
980 && !multiple_inferiors_p ())
981 fprintf_unfiltered (mi->raw_stdout, "*running,thread-id=\"all\"\n");
983 for (thread_info *tp : all_non_exited_threads (ptid))
984 mi_output_running (tp);
986 if (!running_result_record_printed && mi_proceeded)
988 running_result_record_printed = 1;
989 /* This is what gdb used to do historically -- printing prompt
990 even if it cannot actually accept any input. This will be
991 surely removed for MI3, and may be removed even earlier. */
992 if (current_ui->prompt_state == PROMPT_BLOCKED)
993 fputs_unfiltered ("(gdb) \n", mi->raw_stdout);
995 gdb_flush (mi->raw_stdout);
999 mi_on_resume (ptid_t ptid)
1001 struct thread_info *tp = NULL;
1003 if (ptid == minus_one_ptid || ptid.is_pid ())
1004 tp = inferior_thread ();
1006 tp = find_thread_ptid (ptid);
1008 /* Suppress output while calling an inferior function. */
1009 if (tp->control.in_infcall)
1012 SWITCH_THRU_ALL_UIS ()
1014 struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
1019 target_terminal::scoped_restore_terminal_state term_state;
1020 target_terminal::ours_for_output ();
1022 mi_on_resume_1 (mi, ptid);
1026 /* See mi-interp.h. */
1029 mi_output_solib_attribs (ui_out *uiout, struct so_list *solib)
1031 struct gdbarch *gdbarch = target_gdbarch ();
1033 uiout->field_string ("id", solib->so_original_name);
1034 uiout->field_string ("target-name", solib->so_original_name);
1035 uiout->field_string ("host-name", solib->so_name);
1036 uiout->field_int ("symbols-loaded", solib->symbols_loaded);
1037 if (!gdbarch_has_global_solist (target_gdbarch ()))
1038 uiout->field_fmt ("thread-group", "i%d", current_inferior ()->num);
1040 ui_out_emit_list list_emitter (uiout, "ranges");
1041 ui_out_emit_tuple tuple_emitter (uiout, NULL);
1042 if (solib->addr_high != 0)
1044 uiout->field_core_addr ("from", gdbarch, solib->addr_low);
1045 uiout->field_core_addr ("to", gdbarch, solib->addr_high);
1050 mi_solib_loaded (struct so_list *solib)
1052 SWITCH_THRU_ALL_UIS ()
1054 struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
1055 struct ui_out *uiout;
1060 uiout = top_level_interpreter ()->interp_ui_out ();
1062 target_terminal::scoped_restore_terminal_state term_state;
1063 target_terminal::ours_for_output ();
1065 fprintf_unfiltered (mi->event_channel, "library-loaded");
1067 uiout->redirect (mi->event_channel);
1069 mi_output_solib_attribs (uiout, solib);
1071 uiout->redirect (NULL);
1073 gdb_flush (mi->event_channel);
1078 mi_solib_unloaded (struct so_list *solib)
1080 SWITCH_THRU_ALL_UIS ()
1082 struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
1083 struct ui_out *uiout;
1088 uiout = top_level_interpreter ()->interp_ui_out ();
1090 target_terminal::scoped_restore_terminal_state term_state;
1091 target_terminal::ours_for_output ();
1093 fprintf_unfiltered (mi->event_channel, "library-unloaded");
1095 uiout->redirect (mi->event_channel);
1097 uiout->field_string ("id", solib->so_original_name);
1098 uiout->field_string ("target-name", solib->so_original_name);
1099 uiout->field_string ("host-name", solib->so_name);
1100 if (!gdbarch_has_global_solist (target_gdbarch ()))
1102 uiout->field_fmt ("thread-group", "i%d", current_inferior ()->num);
1105 uiout->redirect (NULL);
1107 gdb_flush (mi->event_channel);
1111 /* Emit notification about the command parameter change. */
1114 mi_command_param_changed (const char *param, const char *value)
1116 if (mi_suppress_notification.cmd_param_changed)
1119 SWITCH_THRU_ALL_UIS ()
1121 struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
1122 struct ui_out *mi_uiout;
1127 mi_uiout = top_level_interpreter ()->interp_ui_out ();
1129 target_terminal::scoped_restore_terminal_state term_state;
1130 target_terminal::ours_for_output ();
1132 fprintf_unfiltered (mi->event_channel, "cmd-param-changed");
1134 mi_uiout->redirect (mi->event_channel);
1136 mi_uiout->field_string ("param", param);
1137 mi_uiout->field_string ("value", value);
1139 mi_uiout->redirect (NULL);
1141 gdb_flush (mi->event_channel);
1145 /* Emit notification about the target memory change. */
1148 mi_memory_changed (struct inferior *inferior, CORE_ADDR memaddr,
1149 ssize_t len, const bfd_byte *myaddr)
1151 if (mi_suppress_notification.memory)
1154 SWITCH_THRU_ALL_UIS ()
1156 struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
1157 struct ui_out *mi_uiout;
1158 struct obj_section *sec;
1163 mi_uiout = top_level_interpreter ()->interp_ui_out ();
1165 target_terminal::scoped_restore_terminal_state term_state;
1166 target_terminal::ours_for_output ();
1168 fprintf_unfiltered (mi->event_channel, "memory-changed");
1170 mi_uiout->redirect (mi->event_channel);
1172 mi_uiout->field_fmt ("thread-group", "i%d", inferior->num);
1173 mi_uiout->field_core_addr ("addr", target_gdbarch (), memaddr);
1174 mi_uiout->field_fmt ("len", "%s", hex_string (len));
1176 /* Append 'type=code' into notification if MEMADDR falls in the range of
1177 sections contain code. */
1178 sec = find_pc_section (memaddr);
1179 if (sec != NULL && sec->objfile != NULL)
1181 flagword flags = bfd_get_section_flags (sec->objfile->obfd,
1182 sec->the_bfd_section);
1184 if (flags & SEC_CODE)
1185 mi_uiout->field_string ("type", "code");
1188 mi_uiout->redirect (NULL);
1190 gdb_flush (mi->event_channel);
1194 /* Emit an event when the selection context (inferior, thread, frame)
1198 mi_user_selected_context_changed (user_selected_what selection)
1200 struct thread_info *tp;
1202 /* Don't send an event if we're responding to an MI command. */
1203 if (mi_suppress_notification.user_selected_context)
1206 if (inferior_ptid != null_ptid)
1207 tp = inferior_thread ();
1211 SWITCH_THRU_ALL_UIS ()
1213 struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
1214 struct ui_out *mi_uiout;
1219 mi_uiout = top_level_interpreter ()->interp_ui_out ();
1221 mi_uiout->redirect (mi->event_channel);
1222 ui_out_redirect_pop redirect_popper (mi_uiout);
1224 target_terminal::scoped_restore_terminal_state term_state;
1225 target_terminal::ours_for_output ();
1227 if (selection & USER_SELECTED_INFERIOR)
1228 print_selected_inferior (mi->cli_uiout);
1231 && (selection & (USER_SELECTED_THREAD | USER_SELECTED_FRAME)))
1233 print_selected_thread_frame (mi->cli_uiout, selection);
1235 fprintf_unfiltered (mi->event_channel,
1236 "thread-selected,id=\"%d\"",
1239 if (tp->state != THREAD_RUNNING)
1241 if (has_stack_frames ())
1242 print_stack_frame_to_uiout (mi_uiout, get_selected_frame (NULL),
1247 gdb_flush (mi->event_channel);
1252 report_initial_inferior (struct inferior *inf, void *closure)
1254 /* This function is called from mi_interpreter_init, and since
1255 mi_inferior_added assumes that inferior is fully initialized
1256 and top_level_interpreter_data is set, we cannot call
1258 struct mi_interp *mi = (struct mi_interp *) closure;
1260 target_terminal::scoped_restore_terminal_state term_state;
1261 target_terminal::ours_for_output ();
1263 fprintf_unfiltered (mi->event_channel,
1264 "thread-group-added,id=\"i%d\"",
1266 gdb_flush (mi->event_channel);
1272 mi_interp::interp_ui_out ()
1274 return this->mi_uiout;
1277 /* Do MI-specific logging actions; save raw_stdout, and change all
1278 the consoles to use the supplied ui-file(s). */
1281 mi_interp::set_logging (ui_file_up logfile, bool logging_redirect)
1283 struct mi_interp *mi = this;
1285 if (logfile != NULL)
1287 mi->saved_raw_stdout = mi->raw_stdout;
1288 mi->raw_stdout = make_logging_output (mi->raw_stdout,
1289 std::move (logfile),
1295 delete mi->raw_stdout;
1296 mi->raw_stdout = mi->saved_raw_stdout;
1297 mi->saved_raw_stdout = NULL;
1300 mi->out->set_raw (mi->raw_stdout);
1301 mi->err->set_raw (mi->raw_stdout);
1302 mi->log->set_raw (mi->raw_stdout);
1303 mi->targ->set_raw (mi->raw_stdout);
1304 mi->event_channel->set_raw (mi->raw_stdout);
1307 /* Factory for MI interpreters. */
1309 static struct interp *
1310 mi_interp_factory (const char *name)
1312 return new mi_interp (name);
1316 _initialize_mi_interp (void)
1318 /* The various interpreter levels. */
1319 interp_factory_register (INTERP_MI1, mi_interp_factory);
1320 interp_factory_register (INTERP_MI2, mi_interp_factory);
1321 interp_factory_register (INTERP_MI3, mi_interp_factory);
1322 interp_factory_register (INTERP_MI, mi_interp_factory);
1324 gdb::observers::signal_received.attach (mi_on_signal_received);
1325 gdb::observers::end_stepping_range.attach (mi_on_end_stepping_range);
1326 gdb::observers::signal_exited.attach (mi_on_signal_exited);
1327 gdb::observers::exited.attach (mi_on_exited);
1328 gdb::observers::no_history.attach (mi_on_no_history);
1329 gdb::observers::new_thread.attach (mi_new_thread);
1330 gdb::observers::thread_exit.attach (mi_thread_exit);
1331 gdb::observers::inferior_added.attach (mi_inferior_added);
1332 gdb::observers::inferior_appeared.attach (mi_inferior_appeared);
1333 gdb::observers::inferior_exit.attach (mi_inferior_exit);
1334 gdb::observers::inferior_removed.attach (mi_inferior_removed);
1335 gdb::observers::record_changed.attach (mi_record_changed);
1336 gdb::observers::normal_stop.attach (mi_on_normal_stop);
1337 gdb::observers::target_resumed.attach (mi_on_resume);
1338 gdb::observers::solib_loaded.attach (mi_solib_loaded);
1339 gdb::observers::solib_unloaded.attach (mi_solib_unloaded);
1340 gdb::observers::about_to_proceed.attach (mi_about_to_proceed);
1341 gdb::observers::traceframe_changed.attach (mi_traceframe_changed);
1342 gdb::observers::tsv_created.attach (mi_tsv_created);
1343 gdb::observers::tsv_deleted.attach (mi_tsv_deleted);
1344 gdb::observers::tsv_modified.attach (mi_tsv_modified);
1345 gdb::observers::breakpoint_created.attach (mi_breakpoint_created);
1346 gdb::observers::breakpoint_deleted.attach (mi_breakpoint_deleted);
1347 gdb::observers::breakpoint_modified.attach (mi_breakpoint_modified);
1348 gdb::observers::command_param_changed.attach (mi_command_param_changed);
1349 gdb::observers::memory_changed.attach (mi_memory_changed);
1350 gdb::observers::sync_execution_done.attach (mi_on_sync_execution_done);
1351 gdb::observers::user_selected_context_changed.attach
1352 (mi_user_selected_context_changed);