1 /* MI Interpreter Definitions and Commands for GDB, the GNU debugger.
2 
3    Copyright (C) 2002-2020 Free Software Foundation, Inc.
4 
5    This file is part of GDB.
6 
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.
11 
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.
16 
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/>.  */
19 
20 #include "defs.h"
21 
22 #include "mi-interp.h"
23 
24 #include "interps.h"
25 #include "event-top.h"
26 #include "gdbsupport/event-loop.h"
27 #include "inferior.h"
28 #include "infrun.h"
29 #include "ui-out.h"
30 #include "top.h"
31 #include "mi-main.h"
32 #include "mi-cmds.h"
33 #include "mi-out.h"
34 #include "mi-console.h"
35 #include "mi-common.h"
36 #include "observable.h"
37 #include "gdbthread.h"
38 #include "solist.h"
39 #include "objfiles.h"
40 #include "tracepoint.h"
41 #include "cli-out.h"
42 #include "thread-fsm.h"
43 #include "cli/cli-interp.h"
44 #include "gdbsupport/scope-exit.h"
45 
46 /* These are the interpreter setup, etc. functions for the MI
47    interpreter.  */
48 
49 static void mi_execute_command_wrapper (const char *cmd);
50 static void mi_execute_command_input_handler
51   (gdb::unique_xmalloc_ptr<char> &&cmd);
52 
53 /* These are hooks that we put in place while doing interpreter_exec
54    so we can report interesting things that happened "behind the MI's
55    back" in this command.  */
56 
57 static int mi_interp_query_hook (const char *ctlstr, va_list ap)
58   ATTRIBUTE_PRINTF (1, 0);
59 
60 static void mi_insert_notify_hooks (void);
61 static void mi_remove_notify_hooks (void);
62 
63 static void mi_on_signal_received (enum gdb_signal siggnal);
64 static void mi_on_end_stepping_range (void);
65 static void mi_on_signal_exited (enum gdb_signal siggnal);
66 static void mi_on_exited (int exitstatus);
67 static void mi_on_normal_stop (struct bpstats *bs, int print_frame);
68 static void mi_on_no_history (void);
69 
70 static void mi_new_thread (struct thread_info *t);
71 static void mi_thread_exit (struct thread_info *t, int silent);
72 static void mi_record_changed (struct inferior*, int, const char *,
73 			       const char *);
74 static void mi_inferior_added (struct inferior *inf);
75 static void mi_inferior_appeared (struct inferior *inf);
76 static void mi_inferior_exit (struct inferior *inf);
77 static void mi_inferior_removed (struct inferior *inf);
78 static void mi_on_resume (ptid_t ptid);
79 static void mi_solib_loaded (struct so_list *solib);
80 static void mi_solib_unloaded (struct so_list *solib);
81 static void mi_about_to_proceed (void);
82 static void mi_traceframe_changed (int tfnum, int tpnum);
83 static void mi_tsv_created (const struct trace_state_variable *tsv);
84 static void mi_tsv_deleted (const struct trace_state_variable *tsv);
85 static void mi_tsv_modified (const struct trace_state_variable *tsv);
86 static void mi_breakpoint_created (struct breakpoint *b);
87 static void mi_breakpoint_deleted (struct breakpoint *b);
88 static void mi_breakpoint_modified (struct breakpoint *b);
89 static void mi_command_param_changed (const char *param, const char *value);
90 static void mi_memory_changed (struct inferior *inf, CORE_ADDR memaddr,
91 			       ssize_t len, const bfd_byte *myaddr);
92 static void mi_on_sync_execution_done (void);
93 
94 /* Display the MI prompt.  */
95 
96 static void
display_mi_prompt(struct mi_interp * mi)97 display_mi_prompt (struct mi_interp *mi)
98 {
99   struct ui *ui = current_ui;
100 
101   fputs_unfiltered ("(gdb) \n", mi->raw_stdout);
102   gdb_flush (mi->raw_stdout);
103   ui->prompt_state = PROMPTED;
104 }
105 
106 /* Returns the INTERP's data cast as mi_interp if INTERP is an MI, and
107    returns NULL otherwise.  */
108 
109 static struct mi_interp *
as_mi_interp(struct interp * interp)110 as_mi_interp (struct interp *interp)
111 {
112   return dynamic_cast<mi_interp *> (interp);
113 }
114 
115 void
init(bool top_level)116 mi_interp::init (bool top_level)
117 {
118   mi_interp *mi = this;
119 
120   /* Store the current output channel, so that we can create a console
121      channel that encapsulates and prefixes all gdb_output-type bits
122      coming from the rest of the debugger.  */
123   mi->raw_stdout = gdb_stdout;
124 
125   /* Create MI console channels, each with a different prefix so they
126      can be distinguished.  */
127   mi->out = new mi_console_file (mi->raw_stdout, "~", '"');
128   mi->err = new mi_console_file (mi->raw_stdout, "&", '"');
129   mi->log = mi->err;
130   mi->targ = new mi_console_file (mi->raw_stdout, "@", '"');
131   mi->event_channel = new mi_console_file (mi->raw_stdout, "=", 0);
132   mi->mi_uiout = mi_out_new (name ());
133   gdb_assert (mi->mi_uiout != nullptr);
134   mi->cli_uiout = cli_out_new (mi->out);
135 
136   if (top_level)
137     {
138       /* The initial inferior is created before this function is called, so we
139 	 need to report it explicitly when initializing the top-level MI
140 	 interpreter.
141 
142 	 This is also called when additional MI interpreters are added (using
143 	 the new-ui command), when multiple inferiors possibly exist, so we need
144 	 to use iteration to report all the inferiors.  mi_inferior_added can't
145 	 be used, because it would print the event on all the other MI UIs.  */
146 
147       for (inferior *inf : all_inferiors ())
148 	{
149 	  target_terminal::scoped_restore_terminal_state term_state;
150 	  target_terminal::ours_for_output ();
151 
152 	  fprintf_unfiltered (mi->event_channel,
153 			      "thread-group-added,id=\"i%d\"",
154 			      inf->num);
155 
156 	  gdb_flush (mi->event_channel);
157 	}
158   }
159 }
160 
161 void
resume()162 mi_interp::resume ()
163 {
164   struct mi_interp *mi = this;
165   struct ui *ui = current_ui;
166 
167   /* As per hack note in mi_interpreter_init, swap in the output
168      channels... */
169   gdb_setup_readline (0);
170 
171   ui->call_readline = gdb_readline_no_editing_callback;
172   ui->input_handler = mi_execute_command_input_handler;
173 
174   gdb_stdout = mi->out;
175   /* Route error and log output through the MI.  */
176   gdb_stderr = mi->err;
177   gdb_stdlog = mi->log;
178   /* Route target output through the MI.  */
179   gdb_stdtarg = mi->targ;
180   /* Route target error through the MI as well.  */
181   gdb_stdtargerr = mi->targ;
182 
183   /* Replace all the hooks that we know about.  There really needs to
184      be a better way of doing this... */
185   clear_interpreter_hooks ();
186 
187   deprecated_show_load_progress = mi_load_progress;
188 }
189 
190 void
suspend()191 mi_interp::suspend ()
192 {
193   gdb_disable_readline ();
194 }
195 
196 gdb_exception
exec(const char * command)197 mi_interp::exec (const char *command)
198 {
199   mi_execute_command_wrapper (command);
200   return gdb_exception ();
201 }
202 
203 void
mi_cmd_interpreter_exec(const char * command,char ** argv,int argc)204 mi_cmd_interpreter_exec (const char *command, char **argv, int argc)
205 {
206   struct interp *interp_to_use;
207   int i;
208 
209   if (argc < 2)
210     error (_("-interpreter-exec: "
211 	     "Usage: -interpreter-exec interp command"));
212 
213   interp_to_use = interp_lookup (current_ui, argv[0]);
214   if (interp_to_use == NULL)
215     error (_("-interpreter-exec: could not find interpreter \"%s\""),
216 	   argv[0]);
217 
218   /* Note that unlike the CLI version of this command, we don't
219      actually set INTERP_TO_USE as the current interpreter, as we
220      still want gdb_stdout, etc. to point at MI streams.  */
221 
222   /* Insert the MI out hooks, making sure to also call the
223      interpreter's hooks if it has any.  */
224   /* KRS: We shouldn't need this... Events should be installed and
225      they should just ALWAYS fire something out down the MI
226      channel.  */
227   mi_insert_notify_hooks ();
228 
229   /* Now run the code.  */
230 
231   SCOPE_EXIT
232     {
233       mi_remove_notify_hooks ();
234     };
235 
236   for (i = 1; i < argc; i++)
237     {
238       struct gdb_exception e = interp_exec (interp_to_use, argv[i]);
239 
240       if (e.reason < 0)
241 	error ("%s", e.what ());
242     }
243 }
244 
245 /* This inserts a number of hooks that are meant to produce
246    async-notify ("=") MI messages while running commands in another
247    interpreter using mi_interpreter_exec.  The canonical use for this
248    is to allow access to the gdb CLI interpreter from within the MI,
249    while still producing MI style output when actions in the CLI
250    command change GDB's state.  */
251 
252 static void
mi_insert_notify_hooks(void)253 mi_insert_notify_hooks (void)
254 {
255   deprecated_query_hook = mi_interp_query_hook;
256 }
257 
258 static void
mi_remove_notify_hooks(void)259 mi_remove_notify_hooks (void)
260 {
261   deprecated_query_hook = NULL;
262 }
263 
264 static int
mi_interp_query_hook(const char * ctlstr,va_list ap)265 mi_interp_query_hook (const char *ctlstr, va_list ap)
266 {
267   return 1;
268 }
269 
270 static void
mi_execute_command_wrapper(const char * cmd)271 mi_execute_command_wrapper (const char *cmd)
272 {
273   struct ui *ui = current_ui;
274 
275   mi_execute_command (cmd, ui->instream == ui->stdin_stream);
276 }
277 
278 /* Observer for the synchronous_command_done notification.  */
279 
280 static void
mi_on_sync_execution_done(void)281 mi_on_sync_execution_done (void)
282 {
283   struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
284 
285   if (mi == NULL)
286     return;
287 
288   /* If MI is sync, then output the MI prompt now, indicating we're
289      ready for further input.  */
290   if (!mi_async_p ())
291     display_mi_prompt (mi);
292 }
293 
294 /* mi_execute_command_wrapper wrapper suitable for INPUT_HANDLER.  */
295 
296 static void
mi_execute_command_input_handler(gdb::unique_xmalloc_ptr<char> && cmd)297 mi_execute_command_input_handler (gdb::unique_xmalloc_ptr<char> &&cmd)
298 {
299   struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
300   struct ui *ui = current_ui;
301 
302   ui->prompt_state = PROMPT_NEEDED;
303 
304   mi_execute_command_wrapper (cmd.get ());
305 
306   /* Print a prompt, indicating we're ready for further input, unless
307      we just started a synchronous command.  In that case, we're about
308      to go back to the event loop and will output the prompt in the
309      'synchronous_command_done' observer when the target next
310      stops.  */
311   if (ui->prompt_state == PROMPT_NEEDED)
312     display_mi_prompt (mi);
313 }
314 
315 void
pre_command_loop()316 mi_interp::pre_command_loop ()
317 {
318   struct mi_interp *mi = this;
319 
320   /* Turn off 8 bit strings in quoted output.  Any character with the
321      high bit set is printed using C's octal format.  */
322   sevenbit_strings = 1;
323 
324   /* Tell the world that we're alive.  */
325   display_mi_prompt (mi);
326 }
327 
328 static void
mi_new_thread(struct thread_info * t)329 mi_new_thread (struct thread_info *t)
330 {
331   SWITCH_THRU_ALL_UIS ()
332     {
333       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
334 
335       if (mi == NULL)
336 	continue;
337 
338       target_terminal::scoped_restore_terminal_state term_state;
339       target_terminal::ours_for_output ();
340 
341       fprintf_unfiltered (mi->event_channel,
342 			  "thread-created,id=\"%d\",group-id=\"i%d\"",
343 			  t->global_num, t->inf->num);
344       gdb_flush (mi->event_channel);
345     }
346 }
347 
348 static void
mi_thread_exit(struct thread_info * t,int silent)349 mi_thread_exit (struct thread_info *t, int silent)
350 {
351   if (silent)
352     return;
353 
354   SWITCH_THRU_ALL_UIS ()
355     {
356       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
357 
358       if (mi == NULL)
359 	continue;
360 
361       target_terminal::scoped_restore_terminal_state term_state;
362       target_terminal::ours_for_output ();
363       fprintf_unfiltered (mi->event_channel,
364 			  "thread-exited,id=\"%d\",group-id=\"i%d\"",
365 			  t->global_num, t->inf->num);
366       gdb_flush (mi->event_channel);
367     }
368 }
369 
370 /* Emit notification on changing the state of record.  */
371 
372 static void
mi_record_changed(struct inferior * inferior,int started,const char * method,const char * format)373 mi_record_changed (struct inferior *inferior, int started, const char *method,
374 		   const char *format)
375 {
376   SWITCH_THRU_ALL_UIS ()
377     {
378       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
379 
380       if (mi == NULL)
381 	continue;
382 
383       target_terminal::scoped_restore_terminal_state term_state;
384       target_terminal::ours_for_output ();
385 
386       if (started)
387 	{
388 	  if (format != NULL)
389 	    {
390 	      fprintf_unfiltered (mi->event_channel,
391 				  "record-started,thread-group=\"i%d\","
392 				  "method=\"%s\",format=\"%s\"",
393 				  inferior->num, method, format);
394 	    }
395 	  else
396 	    {
397 	      fprintf_unfiltered (mi->event_channel,
398 				  "record-started,thread-group=\"i%d\","
399 				  "method=\"%s\"",
400 				  inferior->num, method);
401 	    }
402 	}
403       else
404 	{
405 	  fprintf_unfiltered (mi->event_channel,
406 			      "record-stopped,thread-group=\"i%d\"",
407 			      inferior->num);
408 	}
409 
410       gdb_flush (mi->event_channel);
411     }
412 }
413 
414 static void
mi_inferior_added(struct inferior * inf)415 mi_inferior_added (struct inferior *inf)
416 {
417   SWITCH_THRU_ALL_UIS ()
418     {
419       struct interp *interp;
420       struct mi_interp *mi;
421 
422       /* We'll be called once for the initial inferior, before the top
423 	 level interpreter is set.  */
424       interp = top_level_interpreter ();
425       if (interp == NULL)
426 	continue;
427 
428       mi = as_mi_interp (interp);
429       if (mi == NULL)
430 	continue;
431 
432       target_terminal::scoped_restore_terminal_state term_state;
433       target_terminal::ours_for_output ();
434 
435       fprintf_unfiltered (mi->event_channel,
436 			  "thread-group-added,id=\"i%d\"",
437 			  inf->num);
438       gdb_flush (mi->event_channel);
439     }
440 }
441 
442 static void
mi_inferior_appeared(struct inferior * inf)443 mi_inferior_appeared (struct inferior *inf)
444 {
445   SWITCH_THRU_ALL_UIS ()
446     {
447       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
448 
449       if (mi == NULL)
450 	continue;
451 
452       target_terminal::scoped_restore_terminal_state term_state;
453       target_terminal::ours_for_output ();
454 
455       fprintf_unfiltered (mi->event_channel,
456 			  "thread-group-started,id=\"i%d\",pid=\"%d\"",
457 			  inf->num, inf->pid);
458       gdb_flush (mi->event_channel);
459     }
460 }
461 
462 static void
mi_inferior_exit(struct inferior * inf)463 mi_inferior_exit (struct inferior *inf)
464 {
465   SWITCH_THRU_ALL_UIS ()
466     {
467       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
468 
469       if (mi == NULL)
470 	continue;
471 
472       target_terminal::scoped_restore_terminal_state term_state;
473       target_terminal::ours_for_output ();
474 
475       if (inf->has_exit_code)
476 	fprintf_unfiltered (mi->event_channel,
477 			    "thread-group-exited,id=\"i%d\",exit-code=\"%s\"",
478 			    inf->num, int_string (inf->exit_code, 8, 0, 0, 1));
479       else
480 	fprintf_unfiltered (mi->event_channel,
481 			    "thread-group-exited,id=\"i%d\"", inf->num);
482 
483       gdb_flush (mi->event_channel);
484     }
485 }
486 
487 static void
mi_inferior_removed(struct inferior * inf)488 mi_inferior_removed (struct inferior *inf)
489 {
490   SWITCH_THRU_ALL_UIS ()
491     {
492       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
493 
494       if (mi == NULL)
495 	continue;
496 
497       target_terminal::scoped_restore_terminal_state term_state;
498       target_terminal::ours_for_output ();
499 
500       fprintf_unfiltered (mi->event_channel,
501 			  "thread-group-removed,id=\"i%d\"",
502 			  inf->num);
503       gdb_flush (mi->event_channel);
504     }
505 }
506 
507 /* Return the MI interpreter, if it is active -- either because it's
508    the top-level interpreter or the interpreter executing the current
509    command.  Returns NULL if the MI interpreter is not being used.  */
510 
511 static struct mi_interp *
find_mi_interp(void)512 find_mi_interp (void)
513 {
514   struct mi_interp *mi;
515 
516   mi = as_mi_interp (top_level_interpreter ());
517   if (mi != NULL)
518     return mi;
519 
520   mi = as_mi_interp (command_interp ());
521   if (mi != NULL)
522     return mi;
523 
524   return NULL;
525 }
526 
527 /* Observers for several run control events that print why the
528    inferior has stopped to both the MI event channel and to the MI
529    console.  If the MI interpreter is not active, print nothing.  */
530 
531 /* Observer for the signal_received notification.  */
532 
533 static void
mi_on_signal_received(enum gdb_signal siggnal)534 mi_on_signal_received (enum gdb_signal siggnal)
535 {
536   SWITCH_THRU_ALL_UIS ()
537     {
538       struct mi_interp *mi = find_mi_interp ();
539 
540       if (mi == NULL)
541 	continue;
542 
543       print_signal_received_reason (mi->mi_uiout, siggnal);
544       print_signal_received_reason (mi->cli_uiout, siggnal);
545     }
546 }
547 
548 /* Observer for the end_stepping_range notification.  */
549 
550 static void
mi_on_end_stepping_range(void)551 mi_on_end_stepping_range (void)
552 {
553   SWITCH_THRU_ALL_UIS ()
554     {
555       struct mi_interp *mi = find_mi_interp ();
556 
557       if (mi == NULL)
558 	continue;
559 
560       print_end_stepping_range_reason (mi->mi_uiout);
561       print_end_stepping_range_reason (mi->cli_uiout);
562     }
563 }
564 
565 /* Observer for the signal_exited notification.  */
566 
567 static void
mi_on_signal_exited(enum gdb_signal siggnal)568 mi_on_signal_exited (enum gdb_signal siggnal)
569 {
570   SWITCH_THRU_ALL_UIS ()
571     {
572       struct mi_interp *mi = find_mi_interp ();
573 
574       if (mi == NULL)
575 	continue;
576 
577       print_signal_exited_reason (mi->mi_uiout, siggnal);
578       print_signal_exited_reason (mi->cli_uiout, siggnal);
579     }
580 }
581 
582 /* Observer for the exited notification.  */
583 
584 static void
mi_on_exited(int exitstatus)585 mi_on_exited (int exitstatus)
586 {
587   SWITCH_THRU_ALL_UIS ()
588     {
589       struct mi_interp *mi = find_mi_interp ();
590 
591       if (mi == NULL)
592 	continue;
593 
594       print_exited_reason (mi->mi_uiout, exitstatus);
595       print_exited_reason (mi->cli_uiout, exitstatus);
596     }
597 }
598 
599 /* Observer for the no_history notification.  */
600 
601 static void
mi_on_no_history(void)602 mi_on_no_history (void)
603 {
604   SWITCH_THRU_ALL_UIS ()
605     {
606       struct mi_interp *mi = find_mi_interp ();
607 
608       if (mi == NULL)
609 	continue;
610 
611       print_no_history_reason (mi->mi_uiout);
612       print_no_history_reason (mi->cli_uiout);
613     }
614 }
615 
616 static void
mi_on_normal_stop_1(struct bpstats * bs,int print_frame)617 mi_on_normal_stop_1 (struct bpstats *bs, int print_frame)
618 {
619   /* Since this can be called when CLI command is executing,
620      using cli interpreter, be sure to use MI uiout for output,
621      not the current one.  */
622   struct ui_out *mi_uiout = top_level_interpreter ()->interp_ui_out ();
623   struct mi_interp *mi = (struct mi_interp *) top_level_interpreter ();
624 
625   if (print_frame)
626     {
627       struct thread_info *tp;
628       int core;
629       struct interp *console_interp;
630 
631       tp = inferior_thread ();
632 
633       if (tp->thread_fsm != NULL
634 	  && tp->thread_fsm->finished_p ())
635 	{
636 	  enum async_reply_reason reason;
637 
638 	  reason = tp->thread_fsm->async_reply_reason ();
639 	  mi_uiout->field_string ("reason", async_reason_lookup (reason));
640 	}
641 
642       console_interp = interp_lookup (current_ui, INTERP_CONSOLE);
643       /* We only want to print the displays once, and we want it to
644 	 look just how it would on the console, so we use this to
645 	 decide whether the MI stop should include them.  */
646       bool console_print = should_print_stop_to_console (console_interp, tp);
647       print_stop_event (mi_uiout, !console_print);
648 
649       if (console_print)
650 	print_stop_event (mi->cli_uiout);
651 
652       mi_uiout->field_signed ("thread-id", tp->global_num);
653       if (non_stop)
654 	{
655 	  ui_out_emit_list list_emitter (mi_uiout, "stopped-threads");
656 
657 	  mi_uiout->field_signed (NULL, tp->global_num);
658 	}
659       else
660 	mi_uiout->field_string ("stopped-threads", "all");
661 
662       core = target_core_of_thread (tp->ptid);
663       if (core != -1)
664 	mi_uiout->field_signed ("core", core);
665     }
666 
667   fputs_unfiltered ("*stopped", mi->raw_stdout);
668   mi_out_put (mi_uiout, mi->raw_stdout);
669   mi_out_rewind (mi_uiout);
670   mi_print_timing_maybe (mi->raw_stdout);
671   fputs_unfiltered ("\n", mi->raw_stdout);
672   gdb_flush (mi->raw_stdout);
673 }
674 
675 static void
mi_on_normal_stop(struct bpstats * bs,int print_frame)676 mi_on_normal_stop (struct bpstats *bs, int print_frame)
677 {
678   SWITCH_THRU_ALL_UIS ()
679     {
680       if (as_mi_interp (top_level_interpreter ()) == NULL)
681 	continue;
682 
683       mi_on_normal_stop_1 (bs, print_frame);
684     }
685 }
686 
687 static void
mi_about_to_proceed(void)688 mi_about_to_proceed (void)
689 {
690   /* Suppress output while calling an inferior function.  */
691 
692   if (inferior_ptid != null_ptid)
693     {
694       struct thread_info *tp = inferior_thread ();
695 
696       if (tp->control.in_infcall)
697 	return;
698     }
699 
700   mi_proceeded = 1;
701 }
702 
703 /* When the element is non-zero, no MI notifications will be emitted in
704    response to the corresponding observers.  */
705 
706 struct mi_suppress_notification mi_suppress_notification =
707   {
708     0,
709     0,
710     0,
711     0,
712   };
713 
714 /* Emit notification on changing a traceframe.  */
715 
716 static void
mi_traceframe_changed(int tfnum,int tpnum)717 mi_traceframe_changed (int tfnum, int tpnum)
718 {
719   if (mi_suppress_notification.traceframe)
720     return;
721 
722   SWITCH_THRU_ALL_UIS ()
723     {
724       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
725 
726       if (mi == NULL)
727 	continue;
728 
729       target_terminal::scoped_restore_terminal_state term_state;
730       target_terminal::ours_for_output ();
731 
732       if (tfnum >= 0)
733 	fprintf_unfiltered (mi->event_channel, "traceframe-changed,"
734 			    "num=\"%d\",tracepoint=\"%d\"\n",
735 			    tfnum, tpnum);
736       else
737 	fprintf_unfiltered (mi->event_channel, "traceframe-changed,end");
738 
739       gdb_flush (mi->event_channel);
740     }
741 }
742 
743 /* Emit notification on creating a trace state variable.  */
744 
745 static void
mi_tsv_created(const struct trace_state_variable * tsv)746 mi_tsv_created (const struct trace_state_variable *tsv)
747 {
748   SWITCH_THRU_ALL_UIS ()
749     {
750       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
751 
752       if (mi == NULL)
753 	continue;
754 
755       target_terminal::scoped_restore_terminal_state term_state;
756       target_terminal::ours_for_output ();
757 
758       fprintf_unfiltered (mi->event_channel, "tsv-created,"
759 			  "name=\"%s\",initial=\"%s\"\n",
760 			  tsv->name.c_str (), plongest (tsv->initial_value));
761 
762       gdb_flush (mi->event_channel);
763     }
764 }
765 
766 /* Emit notification on deleting a trace state variable.  */
767 
768 static void
mi_tsv_deleted(const struct trace_state_variable * tsv)769 mi_tsv_deleted (const struct trace_state_variable *tsv)
770 {
771   SWITCH_THRU_ALL_UIS ()
772     {
773       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
774 
775       if (mi == NULL)
776 	continue;
777 
778       target_terminal::scoped_restore_terminal_state term_state;
779       target_terminal::ours_for_output ();
780 
781       if (tsv != NULL)
782 	fprintf_unfiltered (mi->event_channel, "tsv-deleted,"
783 			    "name=\"%s\"\n", tsv->name.c_str ());
784       else
785 	fprintf_unfiltered (mi->event_channel, "tsv-deleted\n");
786 
787       gdb_flush (mi->event_channel);
788     }
789 }
790 
791 /* Emit notification on modifying a trace state variable.  */
792 
793 static void
mi_tsv_modified(const struct trace_state_variable * tsv)794 mi_tsv_modified (const struct trace_state_variable *tsv)
795 {
796   SWITCH_THRU_ALL_UIS ()
797     {
798       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
799       struct ui_out *mi_uiout;
800 
801       if (mi == NULL)
802 	continue;
803 
804       mi_uiout = top_level_interpreter ()->interp_ui_out ();
805 
806       target_terminal::scoped_restore_terminal_state term_state;
807       target_terminal::ours_for_output ();
808 
809       fprintf_unfiltered (mi->event_channel,
810 			  "tsv-modified");
811 
812       mi_uiout->redirect (mi->event_channel);
813 
814       mi_uiout->field_string ("name", tsv->name);
815       mi_uiout->field_string ("initial",
816 			   plongest (tsv->initial_value));
817       if (tsv->value_known)
818 	mi_uiout->field_string ("current", plongest (tsv->value));
819 
820       mi_uiout->redirect (NULL);
821 
822       gdb_flush (mi->event_channel);
823     }
824 }
825 
826 /* Print breakpoint BP on MI's event channel.  */
827 
828 static void
mi_print_breakpoint_for_event(struct mi_interp * mi,breakpoint * bp)829 mi_print_breakpoint_for_event (struct mi_interp *mi, breakpoint *bp)
830 {
831   ui_out *mi_uiout = mi->interp_ui_out ();
832 
833   /* We want the output from print_breakpoint to go to
834      mi->event_channel.  One approach would be to just call
835      print_breakpoint, and then use mi_out_put to send the current
836      content of mi_uiout into mi->event_channel.  However, that will
837      break if anything is output to mi_uiout prior to calling the
838      breakpoint_created notifications.  So, we use
839      ui_out_redirect.  */
840   mi_uiout->redirect (mi->event_channel);
841 
842   try
843     {
844       scoped_restore restore_uiout
845 	= make_scoped_restore (&current_uiout, mi_uiout);
846 
847       print_breakpoint (bp);
848     }
849   catch (const gdb_exception &ex)
850     {
851       exception_print (gdb_stderr, ex);
852     }
853 
854   mi_uiout->redirect (NULL);
855 }
856 
857 /* Emit notification about a created breakpoint.  */
858 
859 static void
mi_breakpoint_created(struct breakpoint * b)860 mi_breakpoint_created (struct breakpoint *b)
861 {
862   if (mi_suppress_notification.breakpoint)
863     return;
864 
865   if (b->number <= 0)
866     return;
867 
868   SWITCH_THRU_ALL_UIS ()
869     {
870       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
871 
872       if (mi == NULL)
873 	continue;
874 
875       target_terminal::scoped_restore_terminal_state term_state;
876       target_terminal::ours_for_output ();
877 
878       fprintf_unfiltered (mi->event_channel,
879 			  "breakpoint-created");
880       mi_print_breakpoint_for_event (mi, b);
881 
882       gdb_flush (mi->event_channel);
883     }
884 }
885 
886 /* Emit notification about deleted breakpoint.  */
887 
888 static void
mi_breakpoint_deleted(struct breakpoint * b)889 mi_breakpoint_deleted (struct breakpoint *b)
890 {
891   if (mi_suppress_notification.breakpoint)
892     return;
893 
894   if (b->number <= 0)
895     return;
896 
897   SWITCH_THRU_ALL_UIS ()
898     {
899       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
900 
901       if (mi == NULL)
902 	continue;
903 
904       target_terminal::scoped_restore_terminal_state term_state;
905       target_terminal::ours_for_output ();
906 
907       fprintf_unfiltered (mi->event_channel, "breakpoint-deleted,id=\"%d\"",
908 			  b->number);
909 
910       gdb_flush (mi->event_channel);
911     }
912 }
913 
914 /* Emit notification about modified breakpoint.  */
915 
916 static void
mi_breakpoint_modified(struct breakpoint * b)917 mi_breakpoint_modified (struct breakpoint *b)
918 {
919   if (mi_suppress_notification.breakpoint)
920     return;
921 
922   if (b->number <= 0)
923     return;
924 
925   SWITCH_THRU_ALL_UIS ()
926     {
927       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
928 
929       if (mi == NULL)
930 	continue;
931 
932       target_terminal::scoped_restore_terminal_state term_state;
933       target_terminal::ours_for_output ();
934       fprintf_unfiltered (mi->event_channel,
935 			  "breakpoint-modified");
936       mi_print_breakpoint_for_event (mi, b);
937 
938       gdb_flush (mi->event_channel);
939     }
940 }
941 
942 static void
mi_output_running(struct thread_info * thread)943 mi_output_running (struct thread_info *thread)
944 {
945   SWITCH_THRU_ALL_UIS ()
946     {
947       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
948 
949       if (mi == NULL)
950 	continue;
951 
952       fprintf_unfiltered (mi->raw_stdout,
953 			  "*running,thread-id=\"%d\"\n",
954 			  thread->global_num);
955     }
956 }
957 
958 /* Return true if there are multiple inferiors loaded.  This is used
959    for backwards compatibility -- if there's only one inferior, output
960    "all", otherwise, output each resumed thread individually.  */
961 
962 static bool
multiple_inferiors_p()963 multiple_inferiors_p ()
964 {
965   int count = 0;
966   for (inferior *inf ATTRIBUTE_UNUSED : all_non_exited_inferiors ())
967     {
968       count++;
969       if (count > 1)
970 	return true;
971     }
972 
973   return false;
974 }
975 
976 static void
mi_on_resume_1(struct mi_interp * mi,process_stratum_target * targ,ptid_t ptid)977 mi_on_resume_1 (struct mi_interp *mi,
978 		process_stratum_target *targ, ptid_t ptid)
979 {
980   /* To cater for older frontends, emit ^running, but do it only once
981      per each command.  We do it here, since at this point we know
982      that the target was successfully resumed, and in non-async mode,
983      we won't return back to MI interpreter code until the target
984      is done running, so delaying the output of "^running" until then
985      will make it impossible for frontend to know what's going on.
986 
987      In future (MI3), we'll be outputting "^done" here.  */
988   if (!running_result_record_printed && mi_proceeded)
989     {
990       fprintf_unfiltered (mi->raw_stdout, "%s^running\n",
991 			  current_token ? current_token : "");
992     }
993 
994   /* Backwards compatibility.  If doing a wildcard resume and there's
995      only one inferior, output "all", otherwise, output each resumed
996      thread individually.  */
997   if ((ptid == minus_one_ptid || ptid.is_pid ())
998       && !multiple_inferiors_p ())
999     fprintf_unfiltered (mi->raw_stdout, "*running,thread-id=\"all\"\n");
1000   else
1001     for (thread_info *tp : all_non_exited_threads (targ, ptid))
1002       mi_output_running (tp);
1003 
1004   if (!running_result_record_printed && mi_proceeded)
1005     {
1006       running_result_record_printed = 1;
1007       /* This is what gdb used to do historically -- printing prompt
1008 	 even if it cannot actually accept any input.  This will be
1009 	 surely removed for MI3, and may be removed even earlier.  */
1010       if (current_ui->prompt_state == PROMPT_BLOCKED)
1011 	fputs_unfiltered ("(gdb) \n", mi->raw_stdout);
1012     }
1013   gdb_flush (mi->raw_stdout);
1014 }
1015 
1016 static void
mi_on_resume(ptid_t ptid)1017 mi_on_resume (ptid_t ptid)
1018 {
1019   struct thread_info *tp = NULL;
1020 
1021   process_stratum_target *target = current_inferior ()->process_target ();
1022   if (ptid == minus_one_ptid || ptid.is_pid ())
1023     tp = inferior_thread ();
1024   else
1025     tp = find_thread_ptid (target, ptid);
1026 
1027   /* Suppress output while calling an inferior function.  */
1028   if (tp->control.in_infcall)
1029     return;
1030 
1031   SWITCH_THRU_ALL_UIS ()
1032     {
1033       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
1034 
1035       if (mi == NULL)
1036 	continue;
1037 
1038       target_terminal::scoped_restore_terminal_state term_state;
1039       target_terminal::ours_for_output ();
1040 
1041       mi_on_resume_1 (mi, target, ptid);
1042     }
1043 }
1044 
1045 /* See mi-interp.h.  */
1046 
1047 void
mi_output_solib_attribs(ui_out * uiout,struct so_list * solib)1048 mi_output_solib_attribs (ui_out *uiout, struct so_list *solib)
1049 {
1050   struct gdbarch *gdbarch = target_gdbarch ();
1051 
1052   uiout->field_string ("id", solib->so_original_name);
1053   uiout->field_string ("target-name", solib->so_original_name);
1054   uiout->field_string ("host-name", solib->so_name);
1055   uiout->field_signed ("symbols-loaded", solib->symbols_loaded);
1056   if (!gdbarch_has_global_solist (target_gdbarch ()))
1057       uiout->field_fmt ("thread-group", "i%d", current_inferior ()->num);
1058 
1059   ui_out_emit_list list_emitter (uiout, "ranges");
1060   ui_out_emit_tuple tuple_emitter (uiout, NULL);
1061   if (solib->addr_high != 0)
1062     {
1063       uiout->field_core_addr ("from", gdbarch, solib->addr_low);
1064       uiout->field_core_addr ("to", gdbarch, solib->addr_high);
1065     }
1066 }
1067 
1068 static void
mi_solib_loaded(struct so_list * solib)1069 mi_solib_loaded (struct so_list *solib)
1070 {
1071   SWITCH_THRU_ALL_UIS ()
1072     {
1073       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
1074       struct ui_out *uiout;
1075 
1076       if (mi == NULL)
1077 	continue;
1078 
1079       uiout = top_level_interpreter ()->interp_ui_out ();
1080 
1081       target_terminal::scoped_restore_terminal_state term_state;
1082       target_terminal::ours_for_output ();
1083 
1084       fprintf_unfiltered (mi->event_channel, "library-loaded");
1085 
1086       uiout->redirect (mi->event_channel);
1087 
1088       mi_output_solib_attribs (uiout, solib);
1089 
1090       uiout->redirect (NULL);
1091 
1092       gdb_flush (mi->event_channel);
1093     }
1094 }
1095 
1096 static void
mi_solib_unloaded(struct so_list * solib)1097 mi_solib_unloaded (struct so_list *solib)
1098 {
1099   SWITCH_THRU_ALL_UIS ()
1100     {
1101       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
1102       struct ui_out *uiout;
1103 
1104       if (mi == NULL)
1105 	continue;
1106 
1107       uiout = top_level_interpreter ()->interp_ui_out ();
1108 
1109       target_terminal::scoped_restore_terminal_state term_state;
1110       target_terminal::ours_for_output ();
1111 
1112       fprintf_unfiltered (mi->event_channel, "library-unloaded");
1113 
1114       uiout->redirect (mi->event_channel);
1115 
1116       uiout->field_string ("id", solib->so_original_name);
1117       uiout->field_string ("target-name", solib->so_original_name);
1118       uiout->field_string ("host-name", solib->so_name);
1119       if (!gdbarch_has_global_solist (target_gdbarch ()))
1120 	{
1121 	  uiout->field_fmt ("thread-group", "i%d", current_inferior ()->num);
1122 	}
1123 
1124       uiout->redirect (NULL);
1125 
1126       gdb_flush (mi->event_channel);
1127     }
1128 }
1129 
1130 /* Emit notification about the command parameter change.  */
1131 
1132 static void
mi_command_param_changed(const char * param,const char * value)1133 mi_command_param_changed (const char *param, const char *value)
1134 {
1135   if (mi_suppress_notification.cmd_param_changed)
1136     return;
1137 
1138   SWITCH_THRU_ALL_UIS ()
1139     {
1140       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
1141       struct ui_out *mi_uiout;
1142 
1143       if (mi == NULL)
1144 	continue;
1145 
1146       mi_uiout = top_level_interpreter ()->interp_ui_out ();
1147 
1148       target_terminal::scoped_restore_terminal_state term_state;
1149       target_terminal::ours_for_output ();
1150 
1151       fprintf_unfiltered (mi->event_channel, "cmd-param-changed");
1152 
1153       mi_uiout->redirect (mi->event_channel);
1154 
1155       mi_uiout->field_string ("param", param);
1156       mi_uiout->field_string ("value", value);
1157 
1158       mi_uiout->redirect (NULL);
1159 
1160       gdb_flush (mi->event_channel);
1161     }
1162 }
1163 
1164 /* Emit notification about the target memory change.  */
1165 
1166 static void
mi_memory_changed(struct inferior * inferior,CORE_ADDR memaddr,ssize_t len,const bfd_byte * myaddr)1167 mi_memory_changed (struct inferior *inferior, CORE_ADDR memaddr,
1168 		   ssize_t len, const bfd_byte *myaddr)
1169 {
1170   if (mi_suppress_notification.memory)
1171     return;
1172 
1173   SWITCH_THRU_ALL_UIS ()
1174     {
1175       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
1176       struct ui_out *mi_uiout;
1177       struct obj_section *sec;
1178 
1179       if (mi == NULL)
1180 	continue;
1181 
1182       mi_uiout = top_level_interpreter ()->interp_ui_out ();
1183 
1184       target_terminal::scoped_restore_terminal_state term_state;
1185       target_terminal::ours_for_output ();
1186 
1187       fprintf_unfiltered (mi->event_channel, "memory-changed");
1188 
1189       mi_uiout->redirect (mi->event_channel);
1190 
1191       mi_uiout->field_fmt ("thread-group", "i%d", inferior->num);
1192       mi_uiout->field_core_addr ("addr", target_gdbarch (), memaddr);
1193       mi_uiout->field_string ("len", hex_string (len));
1194 
1195       /* Append 'type=code' into notification if MEMADDR falls in the range of
1196 	 sections contain code.  */
1197       sec = find_pc_section (memaddr);
1198       if (sec != NULL && sec->objfile != NULL)
1199 	{
1200 	  flagword flags = bfd_section_flags (sec->the_bfd_section);
1201 
1202 	  if (flags & SEC_CODE)
1203 	    mi_uiout->field_string ("type", "code");
1204 	}
1205 
1206       mi_uiout->redirect (NULL);
1207 
1208       gdb_flush (mi->event_channel);
1209     }
1210 }
1211 
1212 /* Emit an event when the selection context (inferior, thread, frame)
1213    changed.  */
1214 
1215 static void
mi_user_selected_context_changed(user_selected_what selection)1216 mi_user_selected_context_changed (user_selected_what selection)
1217 {
1218   struct thread_info *tp;
1219 
1220   /* Don't send an event if we're responding to an MI command.  */
1221   if (mi_suppress_notification.user_selected_context)
1222     return;
1223 
1224   if (inferior_ptid != null_ptid)
1225     tp = inferior_thread ();
1226   else
1227     tp = NULL;
1228 
1229   SWITCH_THRU_ALL_UIS ()
1230     {
1231       struct mi_interp *mi = as_mi_interp (top_level_interpreter ());
1232       struct ui_out *mi_uiout;
1233 
1234       if (mi == NULL)
1235 	continue;
1236 
1237       mi_uiout = top_level_interpreter ()->interp_ui_out ();
1238 
1239       mi_uiout->redirect (mi->event_channel);
1240       ui_out_redirect_pop redirect_popper (mi_uiout);
1241 
1242       target_terminal::scoped_restore_terminal_state term_state;
1243       target_terminal::ours_for_output ();
1244 
1245       if (selection & USER_SELECTED_INFERIOR)
1246 	print_selected_inferior (mi->cli_uiout);
1247 
1248       if (tp != NULL
1249 	  && (selection & (USER_SELECTED_THREAD | USER_SELECTED_FRAME)))
1250 	{
1251 	  print_selected_thread_frame (mi->cli_uiout, selection);
1252 
1253 	  fprintf_unfiltered (mi->event_channel,
1254 			      "thread-selected,id=\"%d\"",
1255 			      tp->global_num);
1256 
1257 	  if (tp->state != THREAD_RUNNING)
1258 	    {
1259 	      if (has_stack_frames ())
1260 		print_stack_frame_to_uiout (mi_uiout, get_selected_frame (NULL),
1261 					    1, SRC_AND_LOC, 1);
1262 	    }
1263 	}
1264 
1265       gdb_flush (mi->event_channel);
1266     }
1267 }
1268 
1269 ui_out *
interp_ui_out()1270 mi_interp::interp_ui_out ()
1271 {
1272   return this->mi_uiout;
1273 }
1274 
1275 /* Do MI-specific logging actions; save raw_stdout, and change all
1276    the consoles to use the supplied ui-file(s).  */
1277 
1278 void
set_logging(ui_file_up logfile,bool logging_redirect,bool debug_redirect)1279 mi_interp::set_logging (ui_file_up logfile, bool logging_redirect,
1280 			bool debug_redirect)
1281 {
1282   struct mi_interp *mi = this;
1283 
1284   if (logfile != NULL)
1285     {
1286       mi->saved_raw_stdout = mi->raw_stdout;
1287 
1288       /* If something is being redirected, then grab logfile.  */
1289       ui_file *logfile_p = nullptr;
1290       if (logging_redirect || debug_redirect)
1291 	{
1292 	  logfile_p = logfile.get ();
1293 	  mi->saved_raw_file_to_delete = logfile_p;
1294 	}
1295 
1296       /* If something is not being redirected, then a tee containing both the
1297 	 logfile and stdout.  */
1298       ui_file *tee = nullptr;
1299       if (!logging_redirect || !debug_redirect)
1300 	{
1301 	  tee = new tee_file (mi->raw_stdout, std::move (logfile));
1302 	  mi->saved_raw_file_to_delete = tee;
1303 	}
1304 
1305       mi->raw_stdout = logging_redirect ? logfile_p : tee;
1306       mi->raw_stdlog = debug_redirect ? logfile_p : tee;
1307     }
1308   else
1309     {
1310       delete mi->saved_raw_file_to_delete;
1311       mi->raw_stdout = mi->saved_raw_stdout;
1312       mi->saved_raw_stdout = nullptr;
1313       mi->saved_raw_file_to_delete = nullptr;
1314     }
1315 
1316   mi->out->set_raw (mi->raw_stdout);
1317   mi->err->set_raw (mi->raw_stdout);
1318   mi->log->set_raw (mi->raw_stdout);
1319   mi->targ->set_raw (mi->raw_stdout);
1320   mi->event_channel->set_raw (mi->raw_stdout);
1321 }
1322 
1323 /* Factory for MI interpreters.  */
1324 
1325 static struct interp *
mi_interp_factory(const char * name)1326 mi_interp_factory (const char *name)
1327 {
1328   return new mi_interp (name);
1329 }
1330 
1331 void _initialize_mi_interp ();
1332 void
_initialize_mi_interp()1333 _initialize_mi_interp ()
1334 {
1335   /* The various interpreter levels.  */
1336   interp_factory_register (INTERP_MI1, mi_interp_factory);
1337   interp_factory_register (INTERP_MI2, mi_interp_factory);
1338   interp_factory_register (INTERP_MI3, mi_interp_factory);
1339   interp_factory_register (INTERP_MI, mi_interp_factory);
1340 
1341   gdb::observers::signal_received.attach (mi_on_signal_received);
1342   gdb::observers::end_stepping_range.attach (mi_on_end_stepping_range);
1343   gdb::observers::signal_exited.attach (mi_on_signal_exited);
1344   gdb::observers::exited.attach (mi_on_exited);
1345   gdb::observers::no_history.attach (mi_on_no_history);
1346   gdb::observers::new_thread.attach (mi_new_thread);
1347   gdb::observers::thread_exit.attach (mi_thread_exit);
1348   gdb::observers::inferior_added.attach (mi_inferior_added);
1349   gdb::observers::inferior_appeared.attach (mi_inferior_appeared);
1350   gdb::observers::inferior_exit.attach (mi_inferior_exit);
1351   gdb::observers::inferior_removed.attach (mi_inferior_removed);
1352   gdb::observers::record_changed.attach (mi_record_changed);
1353   gdb::observers::normal_stop.attach (mi_on_normal_stop);
1354   gdb::observers::target_resumed.attach (mi_on_resume);
1355   gdb::observers::solib_loaded.attach (mi_solib_loaded);
1356   gdb::observers::solib_unloaded.attach (mi_solib_unloaded);
1357   gdb::observers::about_to_proceed.attach (mi_about_to_proceed);
1358   gdb::observers::traceframe_changed.attach (mi_traceframe_changed);
1359   gdb::observers::tsv_created.attach (mi_tsv_created);
1360   gdb::observers::tsv_deleted.attach (mi_tsv_deleted);
1361   gdb::observers::tsv_modified.attach (mi_tsv_modified);
1362   gdb::observers::breakpoint_created.attach (mi_breakpoint_created);
1363   gdb::observers::breakpoint_deleted.attach (mi_breakpoint_deleted);
1364   gdb::observers::breakpoint_modified.attach (mi_breakpoint_modified);
1365   gdb::observers::command_param_changed.attach (mi_command_param_changed);
1366   gdb::observers::memory_changed.attach (mi_memory_changed);
1367   gdb::observers::sync_execution_done.attach (mi_on_sync_execution_done);
1368   gdb::observers::user_selected_context_changed.attach
1369     (mi_user_selected_context_changed);
1370 }
1371