GDB (xrefs)

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