Update year range in copyright notice of all files owned by the GDB project.
[deliverable/binutils-gdb.git] / gdb / mi / mi-interp.c
1 /* MI Interpreter Definitions and Commands for GDB, the GNU debugger.
2
3 Copyright (C) 2002-2015 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 "gdb.h"
37 #include "objfiles.h"
38 #include "tracepoint.h"
39 #include "cli-out.h"
40
41 /* These are the interpreter setup, etc. functions for the MI
42 interpreter. */
43
44 static void mi_execute_command_wrapper (const char *cmd);
45 static void mi_execute_command_input_handler (char *cmd);
46 static void mi_command_loop (void *data);
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);
68 static void mi_inferior_added (struct inferior *inf);
69 static void mi_inferior_appeared (struct inferior *inf);
70 static void mi_inferior_exit (struct inferior *inf);
71 static void mi_inferior_removed (struct inferior *inf);
72 static void mi_on_resume (ptid_t ptid);
73 static void mi_solib_loaded (struct so_list *solib);
74 static void mi_solib_unloaded (struct so_list *solib);
75 static void mi_about_to_proceed (void);
76 static void mi_traceframe_changed (int tfnum, int tpnum);
77 static void mi_tsv_created (const struct trace_state_variable *tsv);
78 static void mi_tsv_deleted (const struct trace_state_variable *tsv);
79 static void mi_tsv_modified (const struct trace_state_variable *tsv);
80 static void mi_breakpoint_created (struct breakpoint *b);
81 static void mi_breakpoint_deleted (struct breakpoint *b);
82 static void mi_breakpoint_modified (struct breakpoint *b);
83 static void mi_command_param_changed (const char *param, const char *value);
84 static void mi_memory_changed (struct inferior *inf, CORE_ADDR memaddr,
85 ssize_t len, const bfd_byte *myaddr);
86 static void mi_on_sync_execution_done (void);
87
88 static int report_initial_inferior (struct inferior *inf, void *closure);
89
90 static void *
91 mi_interpreter_init (struct interp *interp, int top_level)
92 {
93 struct mi_interp *mi = XNEW (struct mi_interp);
94 const char *name;
95 int mi_version;
96
97 /* Assign the output channel created at startup to its own global,
98 so that we can create a console channel that encapsulates and
99 prefixes all gdb_output-type bits coming from the rest of the
100 debugger. */
101
102 raw_stdout = gdb_stdout;
103
104 /* Create MI console channels, each with a different prefix so they
105 can be distinguished. */
106 mi->out = mi_console_file_new (raw_stdout, "~", '"');
107 mi->err = mi_console_file_new (raw_stdout, "&", '"');
108 mi->log = mi->err;
109 mi->targ = mi_console_file_new (raw_stdout, "@", '"');
110 mi->event_channel = mi_console_file_new (raw_stdout, "=", 0);
111
112 name = interp_name (interp);
113 /* INTERP_MI selects the most recent released version. "mi2" was
114 released as part of GDB 6.0. */
115 if (strcmp (name, INTERP_MI) == 0)
116 mi_version = 2;
117 else if (strcmp (name, INTERP_MI1) == 0)
118 mi_version = 1;
119 else if (strcmp (name, INTERP_MI2) == 0)
120 mi_version = 2;
121 else if (strcmp (name, INTERP_MI3) == 0)
122 mi_version = 3;
123 else
124 gdb_assert_not_reached ("unhandled MI version");
125
126 mi->mi_uiout = mi_out_new (mi_version);
127 mi->cli_uiout = cli_out_new (mi->out);
128
129 /* There are installed even if MI is not the top level interpreter.
130 The callbacks themselves decide whether to be skipped. */
131 observer_attach_signal_received (mi_on_signal_received);
132 observer_attach_end_stepping_range (mi_on_end_stepping_range);
133 observer_attach_signal_exited (mi_on_signal_exited);
134 observer_attach_exited (mi_on_exited);
135 observer_attach_no_history (mi_on_no_history);
136
137 if (top_level)
138 {
139 observer_attach_new_thread (mi_new_thread);
140 observer_attach_thread_exit (mi_thread_exit);
141 observer_attach_inferior_added (mi_inferior_added);
142 observer_attach_inferior_appeared (mi_inferior_appeared);
143 observer_attach_inferior_exit (mi_inferior_exit);
144 observer_attach_inferior_removed (mi_inferior_removed);
145 observer_attach_record_changed (mi_record_changed);
146 observer_attach_normal_stop (mi_on_normal_stop);
147 observer_attach_target_resumed (mi_on_resume);
148 observer_attach_solib_loaded (mi_solib_loaded);
149 observer_attach_solib_unloaded (mi_solib_unloaded);
150 observer_attach_about_to_proceed (mi_about_to_proceed);
151 observer_attach_traceframe_changed (mi_traceframe_changed);
152 observer_attach_tsv_created (mi_tsv_created);
153 observer_attach_tsv_deleted (mi_tsv_deleted);
154 observer_attach_tsv_modified (mi_tsv_modified);
155 observer_attach_breakpoint_created (mi_breakpoint_created);
156 observer_attach_breakpoint_deleted (mi_breakpoint_deleted);
157 observer_attach_breakpoint_modified (mi_breakpoint_modified);
158 observer_attach_command_param_changed (mi_command_param_changed);
159 observer_attach_memory_changed (mi_memory_changed);
160 observer_attach_sync_execution_done (mi_on_sync_execution_done);
161
162 /* The initial inferior is created before this function is
163 called, so we need to report it explicitly. Use iteration in
164 case future version of GDB creates more than one inferior
165 up-front. */
166 iterate_over_inferiors (report_initial_inferior, mi);
167 }
168
169 return mi;
170 }
171
172 static int
173 mi_interpreter_resume (void *data)
174 {
175 struct mi_interp *mi = data;
176
177 /* As per hack note in mi_interpreter_init, swap in the output
178 channels... */
179 gdb_setup_readline ();
180
181 /* These overwrite some of the initialization done in
182 _intialize_event_loop. */
183 call_readline = gdb_readline2;
184 input_handler = mi_execute_command_input_handler;
185 async_command_editing_p = 0;
186 /* FIXME: This is a total hack for now. PB's use of the MI
187 implicitly relies on a bug in the async support which allows
188 asynchronous commands to leak through the commmand loop. The bug
189 involves (but is not limited to) the fact that sync_execution was
190 erroneously initialized to 0. Duplicate by initializing it thus
191 here... */
192 sync_execution = 0;
193
194 gdb_stdout = mi->out;
195 /* Route error and log output through the MI. */
196 gdb_stderr = mi->err;
197 gdb_stdlog = mi->log;
198 /* Route target output through the MI. */
199 gdb_stdtarg = mi->targ;
200 /* Route target error through the MI as well. */
201 gdb_stdtargerr = mi->targ;
202
203 /* Replace all the hooks that we know about. There really needs to
204 be a better way of doing this... */
205 clear_interpreter_hooks ();
206
207 deprecated_show_load_progress = mi_load_progress;
208
209 return 1;
210 }
211
212 static int
213 mi_interpreter_suspend (void *data)
214 {
215 gdb_disable_readline ();
216 return 1;
217 }
218
219 static struct gdb_exception
220 mi_interpreter_exec (void *data, const char *command)
221 {
222 mi_execute_command_wrapper (command);
223 return exception_none;
224 }
225
226 void
227 mi_cmd_interpreter_exec (char *command, char **argv, int argc)
228 {
229 struct interp *interp_to_use;
230 int i;
231 char *mi_error_message = NULL;
232 struct cleanup *old_chain;
233
234 if (argc < 2)
235 error (_("-interpreter-exec: "
236 "Usage: -interpreter-exec interp command"));
237
238 interp_to_use = interp_lookup (argv[0]);
239 if (interp_to_use == NULL)
240 error (_("-interpreter-exec: could not find interpreter \"%s\""),
241 argv[0]);
242
243 /* Note that unlike the CLI version of this command, we don't
244 actually set INTERP_TO_USE as the current interpreter, as we
245 still want gdb_stdout, etc. to point at MI streams. */
246
247 /* Insert the MI out hooks, making sure to also call the
248 interpreter's hooks if it has any. */
249 /* KRS: We shouldn't need this... Events should be installed and
250 they should just ALWAYS fire something out down the MI
251 channel. */
252 mi_insert_notify_hooks ();
253
254 /* Now run the code. */
255
256 old_chain = make_cleanup (null_cleanup, 0);
257 for (i = 1; i < argc; i++)
258 {
259 struct gdb_exception e = interp_exec (interp_to_use, argv[i]);
260
261 if (e.reason < 0)
262 {
263 mi_error_message = xstrdup (e.message);
264 make_cleanup (xfree, mi_error_message);
265 break;
266 }
267 }
268
269 mi_remove_notify_hooks ();
270
271 if (mi_error_message != NULL)
272 error ("%s", mi_error_message);
273 do_cleanups (old_chain);
274 }
275
276 /* This inserts a number of hooks that are meant to produce
277 async-notify ("=") MI messages while running commands in another
278 interpreter using mi_interpreter_exec. The canonical use for this
279 is to allow access to the gdb CLI interpreter from within the MI,
280 while still producing MI style output when actions in the CLI
281 command change GDB's state. */
282
283 static void
284 mi_insert_notify_hooks (void)
285 {
286 deprecated_query_hook = mi_interp_query_hook;
287 }
288
289 static void
290 mi_remove_notify_hooks (void)
291 {
292 deprecated_query_hook = NULL;
293 }
294
295 static int
296 mi_interp_query_hook (const char *ctlstr, va_list ap)
297 {
298 return 1;
299 }
300
301 static void
302 mi_execute_command_wrapper (const char *cmd)
303 {
304 mi_execute_command (cmd, stdin == instream);
305 }
306
307 /* Observer for the synchronous_command_done notification. */
308
309 static void
310 mi_on_sync_execution_done (void)
311 {
312 /* MI generally prints a prompt after a command, indicating it's
313 ready for further input. However, due to an historical wart, if
314 MI async, and a (CLI) synchronous command was issued, then we
315 will print the prompt right after printing "^running", even if we
316 cannot actually accept any input until the target stops. See
317 mi_on_resume. However, if the target is async but MI is sync,
318 then we need to output the MI prompt now, to replicate gdb's
319 behavior when neither the target nor MI are async. (Note this
320 observer is only called by the asynchronous target event handling
321 code.) */
322 if (!mi_async_p ())
323 {
324 fputs_unfiltered ("(gdb) \n", raw_stdout);
325 gdb_flush (raw_stdout);
326 }
327 }
328
329 /* mi_execute_command_wrapper wrapper suitable for INPUT_HANDLER. */
330
331 static void
332 mi_execute_command_input_handler (char *cmd)
333 {
334 mi_execute_command_wrapper (cmd);
335
336 /* MI generally prints a prompt after a command, indicating it's
337 ready for further input. However, due to an historical wart, if
338 MI is async, and a synchronous command was issued, then we will
339 print the prompt right after printing "^running", even if we
340 cannot actually accept any input until the target stops. See
341 mi_on_resume.
342
343 If MI is not async, then we print the prompt when the command
344 finishes. If the target is sync, that means output the prompt
345 now, as in that case executing a command doesn't return until the
346 command is done. However, if the target is async, we go back to
347 the event loop and output the prompt in the
348 'synchronous_command_done' observer. */
349 if (!target_is_async_p () || !sync_execution)
350 {
351 fputs_unfiltered ("(gdb) \n", raw_stdout);
352 gdb_flush (raw_stdout);
353 }
354 }
355
356 static void
357 mi_command_loop (void *data)
358 {
359 /* Turn off 8 bit strings in quoted output. Any character with the
360 high bit set is printed using C's octal format. */
361 sevenbit_strings = 1;
362
363 /* Tell the world that we're alive. */
364 fputs_unfiltered ("(gdb) \n", raw_stdout);
365 gdb_flush (raw_stdout);
366
367 start_event_loop ();
368 }
369
370 static void
371 mi_new_thread (struct thread_info *t)
372 {
373 struct mi_interp *mi = top_level_interpreter_data ();
374 struct inferior *inf = find_inferior_ptid (t->ptid);
375
376 gdb_assert (inf);
377
378 fprintf_unfiltered (mi->event_channel,
379 "thread-created,id=\"%d\",group-id=\"i%d\"",
380 t->num, inf->num);
381 gdb_flush (mi->event_channel);
382 }
383
384 static void
385 mi_thread_exit (struct thread_info *t, int silent)
386 {
387 struct mi_interp *mi;
388 struct inferior *inf;
389 struct cleanup *old_chain;
390
391 if (silent)
392 return;
393
394 inf = find_inferior_ptid (t->ptid);
395
396 mi = top_level_interpreter_data ();
397 old_chain = make_cleanup_restore_target_terminal ();
398 target_terminal_ours ();
399 fprintf_unfiltered (mi->event_channel,
400 "thread-exited,id=\"%d\",group-id=\"i%d\"",
401 t->num, inf->num);
402 gdb_flush (mi->event_channel);
403
404 do_cleanups (old_chain);
405 }
406
407 /* Emit notification on changing the state of record. */
408
409 static void
410 mi_record_changed (struct inferior *inferior, int started)
411 {
412 struct mi_interp *mi = top_level_interpreter_data ();
413
414 fprintf_unfiltered (mi->event_channel, "record-%s,thread-group=\"i%d\"",
415 started ? "started" : "stopped", inferior->num);
416
417 gdb_flush (mi->event_channel);
418 }
419
420 static void
421 mi_inferior_added (struct inferior *inf)
422 {
423 struct mi_interp *mi = top_level_interpreter_data ();
424
425 target_terminal_ours ();
426 fprintf_unfiltered (mi->event_channel,
427 "thread-group-added,id=\"i%d\"",
428 inf->num);
429 gdb_flush (mi->event_channel);
430 }
431
432 static void
433 mi_inferior_appeared (struct inferior *inf)
434 {
435 struct mi_interp *mi = top_level_interpreter_data ();
436
437 target_terminal_ours ();
438 fprintf_unfiltered (mi->event_channel,
439 "thread-group-started,id=\"i%d\",pid=\"%d\"",
440 inf->num, inf->pid);
441 gdb_flush (mi->event_channel);
442 }
443
444 static void
445 mi_inferior_exit (struct inferior *inf)
446 {
447 struct mi_interp *mi = top_level_interpreter_data ();
448
449 target_terminal_ours ();
450 if (inf->has_exit_code)
451 fprintf_unfiltered (mi->event_channel,
452 "thread-group-exited,id=\"i%d\",exit-code=\"%s\"",
453 inf->num, int_string (inf->exit_code, 8, 0, 0, 1));
454 else
455 fprintf_unfiltered (mi->event_channel,
456 "thread-group-exited,id=\"i%d\"", inf->num);
457
458 gdb_flush (mi->event_channel);
459 }
460
461 static void
462 mi_inferior_removed (struct inferior *inf)
463 {
464 struct mi_interp *mi = top_level_interpreter_data ();
465
466 target_terminal_ours ();
467 fprintf_unfiltered (mi->event_channel,
468 "thread-group-removed,id=\"i%d\"",
469 inf->num);
470 gdb_flush (mi->event_channel);
471 }
472
473 /* Cleanup that restores a previous current uiout. */
474
475 static void
476 restore_current_uiout_cleanup (void *arg)
477 {
478 struct ui_out *saved_uiout = arg;
479
480 current_uiout = saved_uiout;
481 }
482
483 /* Return the MI interpreter, if it is active -- either because it's
484 the top-level interpreter or the interpreter executing the current
485 command. Returns NULL if the MI interpreter is not being used. */
486
487 static struct interp *
488 find_mi_interpreter (void)
489 {
490 struct interp *interp;
491
492 interp = top_level_interpreter ();
493 if (ui_out_is_mi_like_p (interp_ui_out (interp)))
494 return interp;
495
496 interp = command_interp ();
497 if (ui_out_is_mi_like_p (interp_ui_out (interp)))
498 return interp;
499
500 return NULL;
501 }
502
503 /* Return the MI_INTERP structure of the active MI interpreter.
504 Returns NULL if MI is not active. */
505
506 static struct mi_interp *
507 mi_interp_data (void)
508 {
509 struct interp *interp = find_mi_interpreter ();
510
511 if (interp != NULL)
512 return interp_data (interp);
513 return NULL;
514 }
515
516 /* Observers for several run control events that print why the
517 inferior has stopped to both the the MI event channel and to the MI
518 console. If the MI interpreter is not active, print nothing. */
519
520 /* Observer for the signal_received notification. */
521
522 static void
523 mi_on_signal_received (enum gdb_signal siggnal)
524 {
525 struct mi_interp *mi = mi_interp_data ();
526
527 if (mi == NULL)
528 return;
529
530 print_signal_received_reason (mi->mi_uiout, siggnal);
531 print_signal_received_reason (mi->cli_uiout, siggnal);
532 }
533
534 /* Observer for the end_stepping_range notification. */
535
536 static void
537 mi_on_end_stepping_range (void)
538 {
539 struct mi_interp *mi = mi_interp_data ();
540
541 if (mi == NULL)
542 return;
543
544 print_end_stepping_range_reason (mi->mi_uiout);
545 print_end_stepping_range_reason (mi->cli_uiout);
546 }
547
548 /* Observer for the signal_exited notification. */
549
550 static void
551 mi_on_signal_exited (enum gdb_signal siggnal)
552 {
553 struct mi_interp *mi = mi_interp_data ();
554
555 if (mi == NULL)
556 return;
557
558 print_signal_exited_reason (mi->mi_uiout, siggnal);
559 print_signal_exited_reason (mi->cli_uiout, siggnal);
560 }
561
562 /* Observer for the exited notification. */
563
564 static void
565 mi_on_exited (int exitstatus)
566 {
567 struct mi_interp *mi = mi_interp_data ();
568
569 if (mi == NULL)
570 return;
571
572 print_exited_reason (mi->mi_uiout, exitstatus);
573 print_exited_reason (mi->cli_uiout, exitstatus);
574 }
575
576 /* Observer for the no_history notification. */
577
578 static void
579 mi_on_no_history (void)
580 {
581 struct mi_interp *mi = mi_interp_data ();
582
583 if (mi == NULL)
584 return;
585
586 print_no_history_reason (mi->mi_uiout);
587 print_no_history_reason (mi->cli_uiout);
588 }
589
590 static void
591 mi_on_normal_stop (struct bpstats *bs, int print_frame)
592 {
593 /* Since this can be called when CLI command is executing,
594 using cli interpreter, be sure to use MI uiout for output,
595 not the current one. */
596 struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
597
598 if (print_frame)
599 {
600 int core;
601
602 if (current_uiout != mi_uiout)
603 {
604 /* The normal_stop function has printed frame information
605 into CLI uiout, or some other non-MI uiout. There's no
606 way we can extract proper fields from random uiout
607 object, so we print the frame again. In practice, this
608 can only happen when running a CLI command in MI. */
609 struct ui_out *saved_uiout = current_uiout;
610 struct target_waitstatus last;
611 ptid_t last_ptid;
612
613 current_uiout = mi_uiout;
614
615 get_last_target_status (&last_ptid, &last);
616 print_stop_event (&last);
617
618 current_uiout = saved_uiout;
619 }
620 /* Otherwise, frame information has already been printed by
621 normal_stop. */
622 else
623 {
624 /* Breakpoint hits should always be mirrored to the console.
625 Deciding what to mirror to the console wrt to breakpoints
626 and random stops gets messy real fast. E.g., say "s"
627 trips on a breakpoint. We'd clearly want to mirror the
628 event to the console in this case. But what about more
629 complicated cases like "s&; thread n; s&", and one of
630 those steps spawning a new thread, and that thread
631 hitting a breakpoint? It's impossible in general to
632 track whether the thread had any relation to the commands
633 that had been executed. So we just simplify and always
634 mirror breakpoints and random events to the console.
635
636 Also, CLI execution commands (-interpreter-exec console
637 "next", for example) in async mode have the opposite
638 issue as described in the "then" branch above --
639 normal_stop has already printed frame information to MI
640 uiout, but nothing has printed the same information to
641 the CLI channel. We should print the source line to the
642 console when stepping or other similar commands, iff the
643 step was started by a console command (but not if it was
644 started with -exec-step or similar). */
645 struct thread_info *tp = inferior_thread ();
646
647 if ((!tp->control.stop_step
648 && !tp->control.proceed_to_finish)
649 || (tp->control.command_interp != NULL
650 && tp->control.command_interp != top_level_interpreter ()))
651 {
652 struct mi_interp *mi = top_level_interpreter_data ();
653 struct target_waitstatus last;
654 ptid_t last_ptid;
655 struct cleanup *old_chain;
656
657 /* Set the current uiout to CLI uiout temporarily. */
658 old_chain = make_cleanup (restore_current_uiout_cleanup,
659 current_uiout);
660 current_uiout = mi->cli_uiout;
661
662 get_last_target_status (&last_ptid, &last);
663 print_stop_event (&last);
664
665 do_cleanups (old_chain);
666 }
667 }
668
669 ui_out_field_int (mi_uiout, "thread-id",
670 pid_to_thread_id (inferior_ptid));
671 if (non_stop)
672 {
673 struct cleanup *back_to = make_cleanup_ui_out_list_begin_end
674 (mi_uiout, "stopped-threads");
675
676 ui_out_field_int (mi_uiout, NULL,
677 pid_to_thread_id (inferior_ptid));
678 do_cleanups (back_to);
679 }
680 else
681 ui_out_field_string (mi_uiout, "stopped-threads", "all");
682
683 core = target_core_of_thread (inferior_ptid);
684 if (core != -1)
685 ui_out_field_int (mi_uiout, "core", core);
686 }
687
688 fputs_unfiltered ("*stopped", raw_stdout);
689 mi_out_put (mi_uiout, raw_stdout);
690 mi_out_rewind (mi_uiout);
691 mi_print_timing_maybe ();
692 fputs_unfiltered ("\n", raw_stdout);
693 gdb_flush (raw_stdout);
694 }
695
696 static void
697 mi_about_to_proceed (void)
698 {
699 /* Suppress output while calling an inferior function. */
700
701 if (!ptid_equal (inferior_ptid, null_ptid))
702 {
703 struct thread_info *tp = inferior_thread ();
704
705 if (tp->control.in_infcall)
706 return;
707 }
708
709 mi_proceeded = 1;
710 }
711
712 /* When the element is non-zero, no MI notifications will be emitted in
713 response to the corresponding observers. */
714
715 struct mi_suppress_notification mi_suppress_notification =
716 {
717 0,
718 0,
719 0,
720 };
721
722 /* Emit notification on changing a traceframe. */
723
724 static void
725 mi_traceframe_changed (int tfnum, int tpnum)
726 {
727 struct mi_interp *mi = top_level_interpreter_data ();
728
729 if (mi_suppress_notification.traceframe)
730 return;
731
732 target_terminal_ours ();
733
734 if (tfnum >= 0)
735 fprintf_unfiltered (mi->event_channel, "traceframe-changed,"
736 "num=\"%d\",tracepoint=\"%d\"\n",
737 tfnum, tpnum);
738 else
739 fprintf_unfiltered (mi->event_channel, "traceframe-changed,end");
740
741 gdb_flush (mi->event_channel);
742 }
743
744 /* Emit notification on creating a trace state variable. */
745
746 static void
747 mi_tsv_created (const struct trace_state_variable *tsv)
748 {
749 struct mi_interp *mi = top_level_interpreter_data ();
750
751 target_terminal_ours ();
752
753 fprintf_unfiltered (mi->event_channel, "tsv-created,"
754 "name=\"%s\",initial=\"%s\"\n",
755 tsv->name, plongest (tsv->initial_value));
756
757 gdb_flush (mi->event_channel);
758 }
759
760 /* Emit notification on deleting a trace state variable. */
761
762 static void
763 mi_tsv_deleted (const struct trace_state_variable *tsv)
764 {
765 struct mi_interp *mi = top_level_interpreter_data ();
766
767 target_terminal_ours ();
768
769 if (tsv != NULL)
770 fprintf_unfiltered (mi->event_channel, "tsv-deleted,"
771 "name=\"%s\"\n", tsv->name);
772 else
773 fprintf_unfiltered (mi->event_channel, "tsv-deleted\n");
774
775 gdb_flush (mi->event_channel);
776 }
777
778 /* Emit notification on modifying a trace state variable. */
779
780 static void
781 mi_tsv_modified (const struct trace_state_variable *tsv)
782 {
783 struct mi_interp *mi = top_level_interpreter_data ();
784 struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
785
786 target_terminal_ours ();
787
788 fprintf_unfiltered (mi->event_channel,
789 "tsv-modified");
790
791 ui_out_redirect (mi_uiout, mi->event_channel);
792
793 ui_out_field_string (mi_uiout, "name", tsv->name);
794 ui_out_field_string (mi_uiout, "initial",
795 plongest (tsv->initial_value));
796 if (tsv->value_known)
797 ui_out_field_string (mi_uiout, "current", plongest (tsv->value));
798
799 ui_out_redirect (mi_uiout, NULL);
800
801 gdb_flush (mi->event_channel);
802 }
803
804 /* Emit notification about a created breakpoint. */
805
806 static void
807 mi_breakpoint_created (struct breakpoint *b)
808 {
809 struct mi_interp *mi = top_level_interpreter_data ();
810 struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
811 volatile struct gdb_exception e;
812
813 if (mi_suppress_notification.breakpoint)
814 return;
815
816 if (b->number <= 0)
817 return;
818
819 target_terminal_ours ();
820 fprintf_unfiltered (mi->event_channel,
821 "breakpoint-created");
822 /* We want the output from gdb_breakpoint_query to go to
823 mi->event_channel. One approach would be to just call
824 gdb_breakpoint_query, and then use mi_out_put to send the current
825 content of mi_outout into mi->event_channel. However, that will
826 break if anything is output to mi_uiout prior to calling the
827 breakpoint_created notifications. So, we use
828 ui_out_redirect. */
829 ui_out_redirect (mi_uiout, mi->event_channel);
830 TRY_CATCH (e, RETURN_MASK_ERROR)
831 gdb_breakpoint_query (mi_uiout, b->number, NULL);
832 ui_out_redirect (mi_uiout, NULL);
833
834 gdb_flush (mi->event_channel);
835 }
836
837 /* Emit notification about deleted breakpoint. */
838
839 static void
840 mi_breakpoint_deleted (struct breakpoint *b)
841 {
842 struct mi_interp *mi = top_level_interpreter_data ();
843
844 if (mi_suppress_notification.breakpoint)
845 return;
846
847 if (b->number <= 0)
848 return;
849
850 target_terminal_ours ();
851
852 fprintf_unfiltered (mi->event_channel, "breakpoint-deleted,id=\"%d\"",
853 b->number);
854
855 gdb_flush (mi->event_channel);
856 }
857
858 /* Emit notification about modified breakpoint. */
859
860 static void
861 mi_breakpoint_modified (struct breakpoint *b)
862 {
863 struct mi_interp *mi = top_level_interpreter_data ();
864 struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
865 volatile struct gdb_exception e;
866
867 if (mi_suppress_notification.breakpoint)
868 return;
869
870 if (b->number <= 0)
871 return;
872
873 target_terminal_ours ();
874 fprintf_unfiltered (mi->event_channel,
875 "breakpoint-modified");
876 /* We want the output from gdb_breakpoint_query to go to
877 mi->event_channel. One approach would be to just call
878 gdb_breakpoint_query, and then use mi_out_put to send the current
879 content of mi_outout into mi->event_channel. However, that will
880 break if anything is output to mi_uiout prior to calling the
881 breakpoint_created notifications. So, we use
882 ui_out_redirect. */
883 ui_out_redirect (mi_uiout, mi->event_channel);
884 TRY_CATCH (e, RETURN_MASK_ERROR)
885 gdb_breakpoint_query (mi_uiout, b->number, NULL);
886 ui_out_redirect (mi_uiout, NULL);
887
888 gdb_flush (mi->event_channel);
889 }
890
891 static int
892 mi_output_running_pid (struct thread_info *info, void *arg)
893 {
894 ptid_t *ptid = arg;
895
896 if (ptid_get_pid (*ptid) == ptid_get_pid (info->ptid))
897 fprintf_unfiltered (raw_stdout,
898 "*running,thread-id=\"%d\"\n",
899 info->num);
900
901 return 0;
902 }
903
904 static int
905 mi_inferior_count (struct inferior *inf, void *arg)
906 {
907 if (inf->pid != 0)
908 {
909 int *count_p = arg;
910 (*count_p)++;
911 }
912
913 return 0;
914 }
915
916 static void
917 mi_on_resume (ptid_t ptid)
918 {
919 struct thread_info *tp = NULL;
920
921 if (ptid_equal (ptid, minus_one_ptid) || ptid_is_pid (ptid))
922 tp = inferior_thread ();
923 else
924 tp = find_thread_ptid (ptid);
925
926 /* Suppress output while calling an inferior function. */
927 if (tp->control.in_infcall)
928 return;
929
930 /* To cater for older frontends, emit ^running, but do it only once
931 per each command. We do it here, since at this point we know
932 that the target was successfully resumed, and in non-async mode,
933 we won't return back to MI interpreter code until the target
934 is done running, so delaying the output of "^running" until then
935 will make it impossible for frontend to know what's going on.
936
937 In future (MI3), we'll be outputting "^done" here. */
938 if (!running_result_record_printed && mi_proceeded)
939 {
940 fprintf_unfiltered (raw_stdout, "%s^running\n",
941 current_token ? current_token : "");
942 }
943
944 if (ptid_get_pid (ptid) == -1)
945 fprintf_unfiltered (raw_stdout, "*running,thread-id=\"all\"\n");
946 else if (ptid_is_pid (ptid))
947 {
948 int count = 0;
949
950 /* Backwards compatibility. If there's only one inferior,
951 output "all", otherwise, output each resumed thread
952 individually. */
953 iterate_over_inferiors (mi_inferior_count, &count);
954
955 if (count == 1)
956 fprintf_unfiltered (raw_stdout, "*running,thread-id=\"all\"\n");
957 else
958 iterate_over_threads (mi_output_running_pid, &ptid);
959 }
960 else
961 {
962 struct thread_info *ti = find_thread_ptid (ptid);
963
964 gdb_assert (ti);
965 fprintf_unfiltered (raw_stdout, "*running,thread-id=\"%d\"\n", ti->num);
966 }
967
968 if (!running_result_record_printed && mi_proceeded)
969 {
970 running_result_record_printed = 1;
971 /* This is what gdb used to do historically -- printing prompt even if
972 it cannot actually accept any input. This will be surely removed
973 for MI3, and may be removed even earlier. SYNC_EXECUTION is
974 checked here because we only need to emit a prompt if a
975 synchronous command was issued when the target is async. */
976 if (!target_is_async_p () || sync_execution)
977 fputs_unfiltered ("(gdb) \n", raw_stdout);
978 }
979 gdb_flush (raw_stdout);
980 }
981
982 static void
983 mi_solib_loaded (struct so_list *solib)
984 {
985 struct mi_interp *mi = top_level_interpreter_data ();
986 struct ui_out *uiout = interp_ui_out (top_level_interpreter ());
987
988 target_terminal_ours ();
989
990 fprintf_unfiltered (mi->event_channel, "library-loaded");
991
992 ui_out_redirect (uiout, mi->event_channel);
993
994 ui_out_field_string (uiout, "id", solib->so_original_name);
995 ui_out_field_string (uiout, "target-name", solib->so_original_name);
996 ui_out_field_string (uiout, "host-name", solib->so_name);
997 ui_out_field_int (uiout, "symbols-loaded", solib->symbols_loaded);
998 if (!gdbarch_has_global_solist (target_gdbarch ()))
999 {
1000 ui_out_field_fmt (uiout, "thread-group", "i%d", current_inferior ()->num);
1001 }
1002
1003 ui_out_redirect (uiout, NULL);
1004
1005 gdb_flush (mi->event_channel);
1006 }
1007
1008 static void
1009 mi_solib_unloaded (struct so_list *solib)
1010 {
1011 struct mi_interp *mi = top_level_interpreter_data ();
1012 struct ui_out *uiout = interp_ui_out (top_level_interpreter ());
1013
1014 target_terminal_ours ();
1015
1016 fprintf_unfiltered (mi->event_channel, "library-unloaded");
1017
1018 ui_out_redirect (uiout, mi->event_channel);
1019
1020 ui_out_field_string (uiout, "id", solib->so_original_name);
1021 ui_out_field_string (uiout, "target-name", solib->so_original_name);
1022 ui_out_field_string (uiout, "host-name", solib->so_name);
1023 if (!gdbarch_has_global_solist (target_gdbarch ()))
1024 {
1025 ui_out_field_fmt (uiout, "thread-group", "i%d", current_inferior ()->num);
1026 }
1027
1028 ui_out_redirect (uiout, NULL);
1029
1030 gdb_flush (mi->event_channel);
1031 }
1032
1033 /* Emit notification about the command parameter change. */
1034
1035 static void
1036 mi_command_param_changed (const char *param, const char *value)
1037 {
1038 struct mi_interp *mi = top_level_interpreter_data ();
1039 struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
1040
1041 if (mi_suppress_notification.cmd_param_changed)
1042 return;
1043
1044 target_terminal_ours ();
1045
1046 fprintf_unfiltered (mi->event_channel,
1047 "cmd-param-changed");
1048
1049 ui_out_redirect (mi_uiout, mi->event_channel);
1050
1051 ui_out_field_string (mi_uiout, "param", param);
1052 ui_out_field_string (mi_uiout, "value", value);
1053
1054 ui_out_redirect (mi_uiout, NULL);
1055
1056 gdb_flush (mi->event_channel);
1057 }
1058
1059 /* Emit notification about the target memory change. */
1060
1061 static void
1062 mi_memory_changed (struct inferior *inferior, CORE_ADDR memaddr,
1063 ssize_t len, const bfd_byte *myaddr)
1064 {
1065 struct mi_interp *mi = top_level_interpreter_data ();
1066 struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
1067 struct obj_section *sec;
1068
1069 if (mi_suppress_notification.memory)
1070 return;
1071
1072 target_terminal_ours ();
1073
1074 fprintf_unfiltered (mi->event_channel,
1075 "memory-changed");
1076
1077 ui_out_redirect (mi_uiout, mi->event_channel);
1078
1079 ui_out_field_fmt (mi_uiout, "thread-group", "i%d", inferior->num);
1080 ui_out_field_core_addr (mi_uiout, "addr", target_gdbarch (), memaddr);
1081 ui_out_field_fmt (mi_uiout, "len", "%s", hex_string (len));
1082
1083 /* Append 'type=code' into notification if MEMADDR falls in the range of
1084 sections contain code. */
1085 sec = find_pc_section (memaddr);
1086 if (sec != NULL && sec->objfile != NULL)
1087 {
1088 flagword flags = bfd_get_section_flags (sec->objfile->obfd,
1089 sec->the_bfd_section);
1090
1091 if (flags & SEC_CODE)
1092 ui_out_field_string (mi_uiout, "type", "code");
1093 }
1094
1095 ui_out_redirect (mi_uiout, NULL);
1096
1097 gdb_flush (mi->event_channel);
1098 }
1099
1100 static int
1101 report_initial_inferior (struct inferior *inf, void *closure)
1102 {
1103 /* This function is called from mi_intepreter_init, and since
1104 mi_inferior_added assumes that inferior is fully initialized
1105 and top_level_interpreter_data is set, we cannot call
1106 it here. */
1107 struct mi_interp *mi = closure;
1108
1109 target_terminal_ours ();
1110 fprintf_unfiltered (mi->event_channel,
1111 "thread-group-added,id=\"i%d\"",
1112 inf->num);
1113 gdb_flush (mi->event_channel);
1114 return 0;
1115 }
1116
1117 static struct ui_out *
1118 mi_ui_out (struct interp *interp)
1119 {
1120 struct mi_interp *mi = interp_data (interp);
1121
1122 return mi->mi_uiout;
1123 }
1124
1125 /* Save the original value of raw_stdout here when logging, so we can
1126 restore correctly when done. */
1127
1128 static struct ui_file *saved_raw_stdout;
1129
1130 /* Do MI-specific logging actions; save raw_stdout, and change all
1131 the consoles to use the supplied ui-file(s). */
1132
1133 static int
1134 mi_set_logging (struct interp *interp, int start_log,
1135 struct ui_file *out, struct ui_file *logfile)
1136 {
1137 struct mi_interp *mi = interp_data (interp);
1138
1139 if (!mi)
1140 return 0;
1141
1142 if (start_log)
1143 {
1144 /* The tee created already is based on gdb_stdout, which for MI
1145 is a console and so we end up in an infinite loop of console
1146 writing to ui_file writing to console etc. So discard the
1147 existing tee (it hasn't been used yet, and MI won't ever use
1148 it), and create one based on raw_stdout instead. */
1149 if (logfile)
1150 {
1151 ui_file_delete (out);
1152 out = tee_file_new (raw_stdout, 0, logfile, 0);
1153 }
1154
1155 saved_raw_stdout = raw_stdout;
1156 raw_stdout = out;
1157 }
1158 else
1159 {
1160 raw_stdout = saved_raw_stdout;
1161 saved_raw_stdout = NULL;
1162 }
1163
1164 mi_console_set_raw (mi->out, raw_stdout);
1165 mi_console_set_raw (mi->err, raw_stdout);
1166 mi_console_set_raw (mi->log, raw_stdout);
1167 mi_console_set_raw (mi->targ, raw_stdout);
1168 mi_console_set_raw (mi->event_channel, raw_stdout);
1169
1170 return 1;
1171 }
1172
1173 extern initialize_file_ftype _initialize_mi_interp; /* -Wmissing-prototypes */
1174
1175 void
1176 _initialize_mi_interp (void)
1177 {
1178 static const struct interp_procs procs =
1179 {
1180 mi_interpreter_init, /* init_proc */
1181 mi_interpreter_resume, /* resume_proc */
1182 mi_interpreter_suspend, /* suspend_proc */
1183 mi_interpreter_exec, /* exec_proc */
1184 mi_ui_out, /* ui_out_proc */
1185 mi_set_logging, /* set_logging_proc */
1186 mi_command_loop /* command_loop_proc */
1187 };
1188
1189 /* The various interpreter levels. */
1190 interp_add (interp_new (INTERP_MI1, &procs));
1191 interp_add (interp_new (INTERP_MI2, &procs));
1192 interp_add (interp_new (INTERP_MI3, &procs));
1193 interp_add (interp_new (INTERP_MI, &procs));
1194 }
This page took 0.053995 seconds and 5 git commands to generate.