Upgrade GDB from 7.4.1 to 7.6.1 on the vendor branch
[dragonfly.git] / contrib / gdb-7 / gdb / mi / mi-interp.c
CommitLineData
5796c8dc
SS
1/* MI Interpreter Definitions and Commands for GDB, the GNU debugger.
2
ef5ccd6c 3 Copyright (C) 2002-2013 Free Software Foundation, Inc.
5796c8dc
SS
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 "gdb_string.h"
22#include "interps.h"
23#include "event-top.h"
24#include "event-loop.h"
25#include "inferior.h"
26#include "ui-out.h"
27#include "top.h"
28#include "exceptions.h"
29#include "mi-main.h"
30#include "mi-cmds.h"
31#include "mi-out.h"
32#include "mi-console.h"
33#include "mi-common.h"
34#include "observer.h"
35#include "gdbthread.h"
36#include "solist.h"
a45ae5f8 37#include "gdb.h"
ef5ccd6c
JM
38#include "objfiles.h"
39#include "tracepoint.h"
5796c8dc 40
ef5ccd6c
JM
41/* These are the interpreter setup, etc. functions for the MI
42 interpreter. */
43
44static void mi_execute_command_wrapper (const char *cmd);
45static void mi_execute_command_input_handler (char *cmd);
5796c8dc
SS
46static void mi_command_loop (int mi_version);
47
48/* These are hooks that we put in place while doing interpreter_exec
ef5ccd6c
JM
49 so we can report interesting things that happened "behind the MI's
50 back" in this command. */
51
5796c8dc 52static int mi_interp_query_hook (const char *ctlstr, va_list ap)
ef5ccd6c 53 ATTRIBUTE_PRINTF (1, 0);
5796c8dc
SS
54
55static void mi3_command_loop (void);
56static void mi2_command_loop (void);
57static void mi1_command_loop (void);
58
59static void mi_insert_notify_hooks (void);
60static void mi_remove_notify_hooks (void);
61static void mi_on_normal_stop (struct bpstats *bs, int print_frame);
62
63static void mi_new_thread (struct thread_info *t);
64static void mi_thread_exit (struct thread_info *t, int silent);
ef5ccd6c 65static void mi_record_changed (struct inferior*, int);
cf7f2e2d
JM
66static void mi_inferior_added (struct inferior *inf);
67static void mi_inferior_appeared (struct inferior *inf);
68static void mi_inferior_exit (struct inferior *inf);
69static void mi_inferior_removed (struct inferior *inf);
5796c8dc
SS
70static void mi_on_resume (ptid_t ptid);
71static void mi_solib_loaded (struct so_list *solib);
72static void mi_solib_unloaded (struct so_list *solib);
73static void mi_about_to_proceed (void);
ef5ccd6c
JM
74static void mi_traceframe_changed (int tfnum, int tpnum);
75static void mi_tsv_created (const struct trace_state_variable *tsv);
76static void mi_tsv_deleted (const struct trace_state_variable *tsv);
77static void mi_tsv_modified (const struct trace_state_variable *tsv);
a45ae5f8
JM
78static void mi_breakpoint_created (struct breakpoint *b);
79static void mi_breakpoint_deleted (struct breakpoint *b);
80static void mi_breakpoint_modified (struct breakpoint *b);
ef5ccd6c
JM
81static void mi_command_param_changed (const char *param, const char *value);
82static void mi_memory_changed (struct inferior *inf, CORE_ADDR memaddr,
83 ssize_t len, const bfd_byte *myaddr);
5796c8dc 84
cf7f2e2d
JM
85static int report_initial_inferior (struct inferior *inf, void *closure);
86
5796c8dc 87static void *
a45ae5f8 88mi_interpreter_init (struct interp *interp, int top_level)
5796c8dc
SS
89{
90 struct mi_interp *mi = XMALLOC (struct mi_interp);
a45ae5f8
JM
91 const char *name;
92 int mi_version;
5796c8dc 93
ef5ccd6c
JM
94 /* Assign the output channel created at startup to its own global,
95 so that we can create a console channel that encapsulates and
96 prefixes all gdb_output-type bits coming from the rest of the
97 debugger. */
5796c8dc 98
ef5ccd6c 99 raw_stdout = gdb_stdout;
5796c8dc 100
ef5ccd6c
JM
101 /* Create MI console channels, each with a different prefix so they
102 can be distinguished. */
5796c8dc
SS
103 mi->out = mi_console_file_new (raw_stdout, "~", '"');
104 mi->err = mi_console_file_new (raw_stdout, "&", '"');
105 mi->log = mi->err;
106 mi->targ = mi_console_file_new (raw_stdout, "@", '"');
107 mi->event_channel = mi_console_file_new (raw_stdout, "=", 0);
108
a45ae5f8
JM
109 name = interp_name (interp);
110 /* INTERP_MI selects the most recent released version. "mi2" was
111 released as part of GDB 6.0. */
112 if (strcmp (name, INTERP_MI) == 0)
113 mi_version = 2;
114 else if (strcmp (name, INTERP_MI1) == 0)
115 mi_version = 1;
116 else if (strcmp (name, INTERP_MI2) == 0)
117 mi_version = 2;
118 else if (strcmp (name, INTERP_MI3) == 0)
119 mi_version = 3;
120 else
121 gdb_assert_not_reached ("unhandled MI version");
122
123 mi->uiout = mi_out_new (mi_version);
124
5796c8dc
SS
125 if (top_level)
126 {
127 observer_attach_new_thread (mi_new_thread);
128 observer_attach_thread_exit (mi_thread_exit);
cf7f2e2d
JM
129 observer_attach_inferior_added (mi_inferior_added);
130 observer_attach_inferior_appeared (mi_inferior_appeared);
5796c8dc 131 observer_attach_inferior_exit (mi_inferior_exit);
cf7f2e2d 132 observer_attach_inferior_removed (mi_inferior_removed);
ef5ccd6c 133 observer_attach_record_changed (mi_record_changed);
5796c8dc
SS
134 observer_attach_normal_stop (mi_on_normal_stop);
135 observer_attach_target_resumed (mi_on_resume);
136 observer_attach_solib_loaded (mi_solib_loaded);
137 observer_attach_solib_unloaded (mi_solib_unloaded);
138 observer_attach_about_to_proceed (mi_about_to_proceed);
ef5ccd6c
JM
139 observer_attach_traceframe_changed (mi_traceframe_changed);
140 observer_attach_tsv_created (mi_tsv_created);
141 observer_attach_tsv_deleted (mi_tsv_deleted);
142 observer_attach_tsv_modified (mi_tsv_modified);
a45ae5f8
JM
143 observer_attach_breakpoint_created (mi_breakpoint_created);
144 observer_attach_breakpoint_deleted (mi_breakpoint_deleted);
145 observer_attach_breakpoint_modified (mi_breakpoint_modified);
ef5ccd6c
JM
146 observer_attach_command_param_changed (mi_command_param_changed);
147 observer_attach_memory_changed (mi_memory_changed);
cf7f2e2d 148
ef5ccd6c
JM
149 /* The initial inferior is created before this function is
150 called, so we need to report it explicitly. Use iteration in
151 case future version of GDB creates more than one inferior
152 up-front. */
cf7f2e2d 153 iterate_over_inferiors (report_initial_inferior, mi);
5796c8dc
SS
154 }
155
156 return mi;
157}
158
159static int
160mi_interpreter_resume (void *data)
161{
162 struct mi_interp *mi = data;
5796c8dc 163
ef5ccd6c
JM
164 /* As per hack note in mi_interpreter_init, swap in the output
165 channels... */
5796c8dc
SS
166 gdb_setup_readline ();
167
168 /* These overwrite some of the initialization done in
169 _intialize_event_loop. */
170 call_readline = gdb_readline2;
ef5ccd6c 171 input_handler = mi_execute_command_input_handler;
5796c8dc
SS
172 add_file_handler (input_fd, stdin_event_handler, 0);
173 async_command_editing_p = 0;
174 /* FIXME: This is a total hack for now. PB's use of the MI
175 implicitly relies on a bug in the async support which allows
176 asynchronous commands to leak through the commmand loop. The bug
177 involves (but is not limited to) the fact that sync_execution was
178 erroneously initialized to 0. Duplicate by initializing it thus
179 here... */
180 sync_execution = 0;
181
182 gdb_stdout = mi->out;
ef5ccd6c 183 /* Route error and log output through the MI. */
5796c8dc
SS
184 gdb_stderr = mi->err;
185 gdb_stdlog = mi->log;
ef5ccd6c 186 /* Route target output through the MI. */
5796c8dc 187 gdb_stdtarg = mi->targ;
ef5ccd6c 188 /* Route target error through the MI as well. */
5796c8dc
SS
189 gdb_stdtargerr = mi->targ;
190
191 /* Replace all the hooks that we know about. There really needs to
192 be a better way of doing this... */
193 clear_interpreter_hooks ();
194
195 deprecated_show_load_progress = mi_load_progress;
196
ef5ccd6c 197 /* If we're _the_ interpreter, take control. */
5796c8dc
SS
198 if (current_interp_named_p (INTERP_MI1))
199 deprecated_command_loop_hook = mi1_command_loop;
200 else if (current_interp_named_p (INTERP_MI2))
201 deprecated_command_loop_hook = mi2_command_loop;
202 else if (current_interp_named_p (INTERP_MI3))
203 deprecated_command_loop_hook = mi3_command_loop;
204 else
205 deprecated_command_loop_hook = mi2_command_loop;
206
207 return 1;
208}
209
210static int
211mi_interpreter_suspend (void *data)
212{
213 gdb_disable_readline ();
214 return 1;
215}
216
217static struct gdb_exception
218mi_interpreter_exec (void *data, const char *command)
219{
ef5ccd6c 220 mi_execute_command_wrapper (command);
5796c8dc
SS
221 return exception_none;
222}
223
ef5ccd6c
JM
224/* Never display the default GDB prompt in MI case. */
225
5796c8dc
SS
226static int
227mi_interpreter_prompt_p (void *data)
228{
229 return 0;
230}
231
232void
233mi_cmd_interpreter_exec (char *command, char **argv, int argc)
234{
235 struct interp *interp_to_use;
236 int i;
5796c8dc
SS
237 char *mi_error_message = NULL;
238 struct cleanup *old_chain;
239
240 if (argc < 2)
c50c785c
JM
241 error (_("-interpreter-exec: "
242 "Usage: -interpreter-exec interp command"));
5796c8dc
SS
243
244 interp_to_use = interp_lookup (argv[0]);
245 if (interp_to_use == NULL)
c50c785c
JM
246 error (_("-interpreter-exec: could not find interpreter \"%s\""),
247 argv[0]);
5796c8dc
SS
248
249 if (!interp_exec_p (interp_to_use))
c50c785c
JM
250 error (_("-interpreter-exec: interpreter \"%s\" "
251 "does not support command execution"),
5796c8dc
SS
252 argv[0]);
253
ef5ccd6c
JM
254 /* Insert the MI out hooks, making sure to also call the
255 interpreter's hooks if it has any. */
256 /* KRS: We shouldn't need this... Events should be installed and
257 they should just ALWAYS fire something out down the MI
258 channel. */
5796c8dc
SS
259 mi_insert_notify_hooks ();
260
ef5ccd6c 261 /* Now run the code. */
5796c8dc
SS
262
263 old_chain = make_cleanup (null_cleanup, 0);
264 for (i = 1; i < argc; i++)
265 {
266 struct gdb_exception e = interp_exec (interp_to_use, argv[i]);
cf7f2e2d 267
5796c8dc
SS
268 if (e.reason < 0)
269 {
270 mi_error_message = xstrdup (e.message);
271 make_cleanup (xfree, mi_error_message);
272 break;
273 }
274 }
275
276 mi_remove_notify_hooks ();
277
278 if (mi_error_message != NULL)
279 error ("%s", mi_error_message);
280 do_cleanups (old_chain);
281}
282
ef5ccd6c
JM
283/* This inserts a number of hooks that are meant to produce
284 async-notify ("=") MI messages while running commands in another
285 interpreter using mi_interpreter_exec. The canonical use for this
286 is to allow access to the gdb CLI interpreter from within the MI,
287 while still producing MI style output when actions in the CLI
288 command change GDB's state. */
5796c8dc
SS
289
290static void
291mi_insert_notify_hooks (void)
292{
293 deprecated_query_hook = mi_interp_query_hook;
294}
295
296static void
297mi_remove_notify_hooks (void)
298{
299 deprecated_query_hook = NULL;
300}
301
302static int
303mi_interp_query_hook (const char *ctlstr, va_list ap)
304{
305 return 1;
306}
307
308static void
ef5ccd6c 309mi_execute_command_wrapper (const char *cmd)
5796c8dc
SS
310{
311 mi_execute_command (cmd, stdin == instream);
312}
313
ef5ccd6c
JM
314/* mi_execute_command_wrapper wrapper suitable for INPUT_HANDLER. */
315
316static void
317mi_execute_command_input_handler (char *cmd)
318{
319 mi_execute_command_wrapper (cmd);
320
321 fputs_unfiltered ("(gdb) \n", raw_stdout);
322 gdb_flush (raw_stdout);
323}
324
5796c8dc
SS
325static void
326mi1_command_loop (void)
327{
328 mi_command_loop (1);
329}
330
331static void
332mi2_command_loop (void)
333{
334 mi_command_loop (2);
335}
336
337static void
338mi3_command_loop (void)
339{
340 mi_command_loop (3);
341}
342
343static void
344mi_command_loop (int mi_version)
345{
346 /* Turn off 8 bit strings in quoted output. Any character with the
ef5ccd6c 347 high bit set is printed using C's octal format. */
5796c8dc 348 sevenbit_strings = 1;
ef5ccd6c
JM
349
350 /* Tell the world that we're alive. */
5796c8dc
SS
351 fputs_unfiltered ("(gdb) \n", raw_stdout);
352 gdb_flush (raw_stdout);
ef5ccd6c 353
5796c8dc
SS
354 start_event_loop ();
355}
356
357static void
358mi_new_thread (struct thread_info *t)
359{
360 struct mi_interp *mi = top_level_interpreter_data ();
cf7f2e2d
JM
361 struct inferior *inf = find_inferior_pid (ptid_get_pid (t->ptid));
362
363 gdb_assert (inf);
5796c8dc
SS
364
365 fprintf_unfiltered (mi->event_channel,
cf7f2e2d
JM
366 "thread-created,id=\"%d\",group-id=\"i%d\"",
367 t->num, inf->num);
5796c8dc
SS
368 gdb_flush (mi->event_channel);
369}
370
371static void
372mi_thread_exit (struct thread_info *t, int silent)
373{
374 struct mi_interp *mi;
cf7f2e2d 375 struct inferior *inf;
5796c8dc
SS
376
377 if (silent)
378 return;
379
cf7f2e2d
JM
380 inf = find_inferior_pid (ptid_get_pid (t->ptid));
381
5796c8dc
SS
382 mi = top_level_interpreter_data ();
383 target_terminal_ours ();
384 fprintf_unfiltered (mi->event_channel,
cf7f2e2d
JM
385 "thread-exited,id=\"%d\",group-id=\"i%d\"",
386 t->num, inf->num);
387 gdb_flush (mi->event_channel);
388}
389
ef5ccd6c
JM
390/* Emit notification on changing the state of record. */
391
392static void
393mi_record_changed (struct inferior *inferior, int started)
394{
395 struct mi_interp *mi = top_level_interpreter_data ();
396
397 fprintf_unfiltered (mi->event_channel, "record-%s,thread-group=\"i%d\"",
398 started ? "started" : "stopped", inferior->num);
399
400 gdb_flush (mi->event_channel);
401}
402
cf7f2e2d
JM
403static void
404mi_inferior_added (struct inferior *inf)
405{
406 struct mi_interp *mi = top_level_interpreter_data ();
407
408 target_terminal_ours ();
409 fprintf_unfiltered (mi->event_channel,
410 "thread-group-added,id=\"i%d\"",
411 inf->num);
5796c8dc
SS
412 gdb_flush (mi->event_channel);
413}
414
415static void
cf7f2e2d 416mi_inferior_appeared (struct inferior *inf)
5796c8dc
SS
417{
418 struct mi_interp *mi = top_level_interpreter_data ();
cf7f2e2d 419
5796c8dc 420 target_terminal_ours ();
cf7f2e2d
JM
421 fprintf_unfiltered (mi->event_channel,
422 "thread-group-started,id=\"i%d\",pid=\"%d\"",
423 inf->num, inf->pid);
5796c8dc
SS
424 gdb_flush (mi->event_channel);
425}
426
427static void
cf7f2e2d 428mi_inferior_exit (struct inferior *inf)
5796c8dc
SS
429{
430 struct mi_interp *mi = top_level_interpreter_data ();
cf7f2e2d 431
5796c8dc 432 target_terminal_ours ();
c50c785c
JM
433 if (inf->has_exit_code)
434 fprintf_unfiltered (mi->event_channel,
435 "thread-group-exited,id=\"i%d\",exit-code=\"%s\"",
436 inf->num, int_string (inf->exit_code, 8, 0, 0, 1));
437 else
438 fprintf_unfiltered (mi->event_channel,
439 "thread-group-exited,id=\"i%d\"", inf->num);
440
5796c8dc
SS
441 gdb_flush (mi->event_channel);
442}
443
cf7f2e2d
JM
444static void
445mi_inferior_removed (struct inferior *inf)
446{
447 struct mi_interp *mi = top_level_interpreter_data ();
448
449 target_terminal_ours ();
450 fprintf_unfiltered (mi->event_channel,
451 "thread-group-removed,id=\"i%d\"",
452 inf->num);
453 gdb_flush (mi->event_channel);
454}
455
5796c8dc
SS
456static void
457mi_on_normal_stop (struct bpstats *bs, int print_frame)
458{
459 /* Since this can be called when CLI command is executing,
460 using cli interpreter, be sure to use MI uiout for output,
461 not the current one. */
462 struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
5796c8dc
SS
463
464 if (print_frame)
465 {
cf7f2e2d
JM
466 int core;
467
a45ae5f8 468 if (current_uiout != mi_uiout)
5796c8dc 469 {
ef5ccd6c
JM
470 /* The normal_stop function has printed frame information
471 into CLI uiout, or some other non-MI uiout. There's no
472 way we can extract proper fields from random uiout
473 object, so we print the frame again. In practice, this
474 can only happen when running a CLI command in MI. */
a45ae5f8
JM
475 struct ui_out *saved_uiout = current_uiout;
476 struct target_waitstatus last;
477 ptid_t last_ptid;
478
479 current_uiout = mi_uiout;
480
481 get_last_target_status (&last_ptid, &last);
482 bpstat_print (bs, last.kind);
cf7f2e2d 483
5796c8dc 484 print_stack_frame (get_selected_frame (NULL), 0, SRC_AND_LOC);
a45ae5f8 485 current_uiout = saved_uiout;
5796c8dc
SS
486 }
487
488 ui_out_field_int (mi_uiout, "thread-id",
489 pid_to_thread_id (inferior_ptid));
490 if (non_stop)
491 {
492 struct cleanup *back_to = make_cleanup_ui_out_list_begin_end
493 (mi_uiout, "stopped-threads");
cf7f2e2d 494
5796c8dc 495 ui_out_field_int (mi_uiout, NULL,
cf7f2e2d 496 pid_to_thread_id (inferior_ptid));
5796c8dc
SS
497 do_cleanups (back_to);
498 }
499 else
500 ui_out_field_string (mi_uiout, "stopped-threads", "all");
cf7f2e2d
JM
501
502 core = target_core_of_thread (inferior_ptid);
503 if (core != -1)
504 ui_out_field_int (mi_uiout, "core", core);
5796c8dc
SS
505 }
506
507 fputs_unfiltered ("*stopped", raw_stdout);
508 mi_out_put (mi_uiout, raw_stdout);
509 mi_out_rewind (mi_uiout);
510 mi_print_timing_maybe ();
511 fputs_unfiltered ("\n", raw_stdout);
512 gdb_flush (raw_stdout);
513}
514
515static void
516mi_about_to_proceed (void)
517{
518 /* Suppress output while calling an inferior function. */
519
520 if (!ptid_equal (inferior_ptid, null_ptid))
521 {
522 struct thread_info *tp = inferior_thread ();
cf7f2e2d 523
c50c785c 524 if (tp->control.in_infcall)
5796c8dc
SS
525 return;
526 }
527
528 mi_proceeded = 1;
529}
530
ef5ccd6c
JM
531/* When the element is non-zero, no MI notifications will be emitted in
532 response to the corresponding observers. */
533
534struct mi_suppress_notification mi_suppress_notification =
535 {
536 0,
537 0,
538 0,
539 };
540
541/* Emit notification on changing a traceframe. */
542
543static void
544mi_traceframe_changed (int tfnum, int tpnum)
545{
546 struct mi_interp *mi = top_level_interpreter_data ();
547
548 if (mi_suppress_notification.traceframe)
549 return;
550
551 target_terminal_ours ();
552
553 if (tfnum >= 0)
554 fprintf_unfiltered (mi->event_channel, "traceframe-changed,"
555 "num=\"%d\",tracepoint=\"%d\"\n",
556 tfnum, tpnum);
557 else
558 fprintf_unfiltered (mi->event_channel, "traceframe-changed,end");
559
560 gdb_flush (mi->event_channel);
561}
562
563/* Emit notification on creating a trace state variable. */
564
565static void
566mi_tsv_created (const struct trace_state_variable *tsv)
567{
568 struct mi_interp *mi = top_level_interpreter_data ();
569
570 target_terminal_ours ();
571
572 fprintf_unfiltered (mi->event_channel, "tsv-created,"
573 "name=\"%s\",initial=\"%s\"\n",
574 tsv->name, plongest (tsv->initial_value));
575
576 gdb_flush (mi->event_channel);
577}
578
579/* Emit notification on deleting a trace state variable. */
580
581static void
582mi_tsv_deleted (const struct trace_state_variable *tsv)
583{
584 struct mi_interp *mi = top_level_interpreter_data ();
585
586 target_terminal_ours ();
587
588 if (tsv != NULL)
589 fprintf_unfiltered (mi->event_channel, "tsv-deleted,"
590 "name=\"%s\"\n", tsv->name);
591 else
592 fprintf_unfiltered (mi->event_channel, "tsv-deleted\n");
593
594 gdb_flush (mi->event_channel);
595}
596
597/* Emit notification on modifying a trace state variable. */
598
599static void
600mi_tsv_modified (const struct trace_state_variable *tsv)
601{
602 struct mi_interp *mi = top_level_interpreter_data ();
603 struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
604
605 target_terminal_ours ();
606
607 fprintf_unfiltered (mi->event_channel,
608 "tsv-modified");
609
610 ui_out_redirect (mi_uiout, mi->event_channel);
611
612 ui_out_field_string (mi_uiout, "name", tsv->name);
613 ui_out_field_string (mi_uiout, "initial",
614 plongest (tsv->initial_value));
615 if (tsv->value_known)
616 ui_out_field_string (mi_uiout, "current", plongest (tsv->value));
617
618 ui_out_redirect (mi_uiout, NULL);
619
620 gdb_flush (mi->event_channel);
621}
a45ae5f8
JM
622
623/* Emit notification about a created breakpoint. */
ef5ccd6c 624
a45ae5f8
JM
625static void
626mi_breakpoint_created (struct breakpoint *b)
627{
628 struct mi_interp *mi = top_level_interpreter_data ();
629 struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
ef5ccd6c 630 volatile struct gdb_exception e;
a45ae5f8 631
ef5ccd6c 632 if (mi_suppress_notification.breakpoint)
a45ae5f8
JM
633 return;
634
635 if (b->number <= 0)
636 return;
637
638 target_terminal_ours ();
639 fprintf_unfiltered (mi->event_channel,
640 "breakpoint-created");
641 /* We want the output from gdb_breakpoint_query to go to
ef5ccd6c
JM
642 mi->event_channel. One approach would be to just call
643 gdb_breakpoint_query, and then use mi_out_put to send the current
644 content of mi_outout into mi->event_channel. However, that will
645 break if anything is output to mi_uiout prior to calling the
646 breakpoint_created notifications. So, we use
647 ui_out_redirect. */
a45ae5f8
JM
648 ui_out_redirect (mi_uiout, mi->event_channel);
649 TRY_CATCH (e, RETURN_MASK_ERROR)
650 gdb_breakpoint_query (mi_uiout, b->number, NULL);
651 ui_out_redirect (mi_uiout, NULL);
652
653 gdb_flush (mi->event_channel);
654}
655
656/* Emit notification about deleted breakpoint. */
ef5ccd6c 657
a45ae5f8
JM
658static void
659mi_breakpoint_deleted (struct breakpoint *b)
660{
661 struct mi_interp *mi = top_level_interpreter_data ();
662
ef5ccd6c 663 if (mi_suppress_notification.breakpoint)
a45ae5f8
JM
664 return;
665
666 if (b->number <= 0)
667 return;
668
669 target_terminal_ours ();
670
671 fprintf_unfiltered (mi->event_channel, "breakpoint-deleted,id=\"%d\"",
672 b->number);
673
674 gdb_flush (mi->event_channel);
675}
676
677/* Emit notification about modified breakpoint. */
ef5ccd6c 678
a45ae5f8
JM
679static void
680mi_breakpoint_modified (struct breakpoint *b)
681{
682 struct mi_interp *mi = top_level_interpreter_data ();
683 struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
ef5ccd6c 684 volatile struct gdb_exception e;
a45ae5f8 685
ef5ccd6c 686 if (mi_suppress_notification.breakpoint)
a45ae5f8
JM
687 return;
688
689 if (b->number <= 0)
690 return;
691
692 target_terminal_ours ();
693 fprintf_unfiltered (mi->event_channel,
694 "breakpoint-modified");
695 /* We want the output from gdb_breakpoint_query to go to
ef5ccd6c
JM
696 mi->event_channel. One approach would be to just call
697 gdb_breakpoint_query, and then use mi_out_put to send the current
698 content of mi_outout into mi->event_channel. However, that will
699 break if anything is output to mi_uiout prior to calling the
700 breakpoint_created notifications. So, we use
701 ui_out_redirect. */
a45ae5f8
JM
702 ui_out_redirect (mi_uiout, mi->event_channel);
703 TRY_CATCH (e, RETURN_MASK_ERROR)
704 gdb_breakpoint_query (mi_uiout, b->number, NULL);
705 ui_out_redirect (mi_uiout, NULL);
706
707 gdb_flush (mi->event_channel);
708}
709
5796c8dc
SS
710static int
711mi_output_running_pid (struct thread_info *info, void *arg)
712{
713 ptid_t *ptid = arg;
714
715 if (ptid_get_pid (*ptid) == ptid_get_pid (info->ptid))
716 fprintf_unfiltered (raw_stdout,
717 "*running,thread-id=\"%d\"\n",
718 info->num);
719
720 return 0;
721}
722
723static int
724mi_inferior_count (struct inferior *inf, void *arg)
725{
726 if (inf->pid != 0)
727 {
728 int *count_p = arg;
729 (*count_p)++;
730 }
731
732 return 0;
733}
734
735static void
736mi_on_resume (ptid_t ptid)
737{
738 struct thread_info *tp = NULL;
739
740 if (ptid_equal (ptid, minus_one_ptid) || ptid_is_pid (ptid))
741 tp = inferior_thread ();
742 else
743 tp = find_thread_ptid (ptid);
744
745 /* Suppress output while calling an inferior function. */
c50c785c 746 if (tp->control.in_infcall)
5796c8dc
SS
747 return;
748
749 /* To cater for older frontends, emit ^running, but do it only once
750 per each command. We do it here, since at this point we know
751 that the target was successfully resumed, and in non-async mode,
752 we won't return back to MI interpreter code until the target
753 is done running, so delaying the output of "^running" until then
754 will make it impossible for frontend to know what's going on.
755
756 In future (MI3), we'll be outputting "^done" here. */
757 if (!running_result_record_printed && mi_proceeded)
758 {
cf7f2e2d
JM
759 fprintf_unfiltered (raw_stdout, "%s^running\n",
760 current_token ? current_token : "");
5796c8dc
SS
761 }
762
763 if (PIDGET (ptid) == -1)
764 fprintf_unfiltered (raw_stdout, "*running,thread-id=\"all\"\n");
765 else if (ptid_is_pid (ptid))
766 {
767 int count = 0;
768
769 /* Backwards compatibility. If there's only one inferior,
770 output "all", otherwise, output each resumed thread
771 individually. */
772 iterate_over_inferiors (mi_inferior_count, &count);
773
774 if (count == 1)
775 fprintf_unfiltered (raw_stdout, "*running,thread-id=\"all\"\n");
776 else
777 iterate_over_threads (mi_output_running_pid, &ptid);
778 }
779 else
780 {
781 struct thread_info *ti = find_thread_ptid (ptid);
cf7f2e2d 782
5796c8dc
SS
783 gdb_assert (ti);
784 fprintf_unfiltered (raw_stdout, "*running,thread-id=\"%d\"\n", ti->num);
785 }
786
787 if (!running_result_record_printed && mi_proceeded)
788 {
789 running_result_record_printed = 1;
790 /* This is what gdb used to do historically -- printing prompt even if
791 it cannot actually accept any input. This will be surely removed
792 for MI3, and may be removed even earler. */
793 /* FIXME: review the use of target_is_async_p here -- is that
794 what we want? */
795 if (!target_is_async_p ())
796 fputs_unfiltered ("(gdb) \n", raw_stdout);
797 }
798 gdb_flush (raw_stdout);
799}
800
801static void
802mi_solib_loaded (struct so_list *solib)
803{
804 struct mi_interp *mi = top_level_interpreter_data ();
cf7f2e2d 805
5796c8dc 806 target_terminal_ours ();
ef5ccd6c 807 if (gdbarch_has_global_solist (target_gdbarch ()))
cf7f2e2d
JM
808 fprintf_unfiltered (mi->event_channel,
809 "library-loaded,id=\"%s\",target-name=\"%s\","
810 "host-name=\"%s\",symbols-loaded=\"%d\"",
811 solib->so_original_name, solib->so_original_name,
812 solib->so_name, solib->symbols_loaded);
813 else
814 fprintf_unfiltered (mi->event_channel,
815 "library-loaded,id=\"%s\",target-name=\"%s\","
816 "host-name=\"%s\",symbols-loaded=\"%d\","
817 "thread-group=\"i%d\"",
818 solib->so_original_name, solib->so_original_name,
819 solib->so_name, solib->symbols_loaded,
820 current_inferior ()->num);
821
5796c8dc
SS
822 gdb_flush (mi->event_channel);
823}
824
825static void
826mi_solib_unloaded (struct so_list *solib)
827{
828 struct mi_interp *mi = top_level_interpreter_data ();
cf7f2e2d 829
5796c8dc 830 target_terminal_ours ();
ef5ccd6c 831 if (gdbarch_has_global_solist (target_gdbarch ()))
cf7f2e2d
JM
832 fprintf_unfiltered (mi->event_channel,
833 "library-unloaded,id=\"%s\",target-name=\"%s\","
834 "host-name=\"%s\"",
835 solib->so_original_name, solib->so_original_name,
836 solib->so_name);
837 else
838 fprintf_unfiltered (mi->event_channel,
839 "library-unloaded,id=\"%s\",target-name=\"%s\","
840 "host-name=\"%s\",thread-group=\"i%d\"",
841 solib->so_original_name, solib->so_original_name,
842 solib->so_name, current_inferior ()->num);
843
5796c8dc
SS
844 gdb_flush (mi->event_channel);
845}
846
ef5ccd6c
JM
847/* Emit notification about the command parameter change. */
848
849static void
850mi_command_param_changed (const char *param, const char *value)
851{
852 struct mi_interp *mi = top_level_interpreter_data ();
853 struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
854
855 if (mi_suppress_notification.cmd_param_changed)
856 return;
857
858 target_terminal_ours ();
859
860 fprintf_unfiltered (mi->event_channel,
861 "cmd-param-changed");
862
863 ui_out_redirect (mi_uiout, mi->event_channel);
864
865 ui_out_field_string (mi_uiout, "param", param);
866 ui_out_field_string (mi_uiout, "value", value);
867
868 ui_out_redirect (mi_uiout, NULL);
869
870 gdb_flush (mi->event_channel);
871}
872
873/* Emit notification about the target memory change. */
874
875static void
876mi_memory_changed (struct inferior *inferior, CORE_ADDR memaddr,
877 ssize_t len, const bfd_byte *myaddr)
878{
879 struct mi_interp *mi = top_level_interpreter_data ();
880 struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
881 struct obj_section *sec;
882
883 if (mi_suppress_notification.memory)
884 return;
885
886 target_terminal_ours ();
887
888 fprintf_unfiltered (mi->event_channel,
889 "memory-changed");
890
891 ui_out_redirect (mi_uiout, mi->event_channel);
892
893 ui_out_field_fmt (mi_uiout, "thread-group", "i%d", inferior->num);
894 ui_out_field_core_addr (mi_uiout, "addr", target_gdbarch (), memaddr);
895 ui_out_field_fmt (mi_uiout, "len", "0x%zx", len);
896
897 /* Append 'type=code' into notification if MEMADDR falls in the range of
898 sections contain code. */
899 sec = find_pc_section (memaddr);
900 if (sec != NULL && sec->objfile != NULL)
901 {
902 flagword flags = bfd_get_section_flags (sec->objfile->obfd,
903 sec->the_bfd_section);
904
905 if (flags & SEC_CODE)
906 ui_out_field_string (mi_uiout, "type", "code");
907 }
908
909 ui_out_redirect (mi_uiout, NULL);
910
911 gdb_flush (mi->event_channel);
912}
913
cf7f2e2d
JM
914static int
915report_initial_inferior (struct inferior *inf, void *closure)
916{
917 /* This function is called from mi_intepreter_init, and since
918 mi_inferior_added assumes that inferior is fully initialized
919 and top_level_interpreter_data is set, we cannot call
920 it here. */
921 struct mi_interp *mi = closure;
922
923 target_terminal_ours ();
924 fprintf_unfiltered (mi->event_channel,
925 "thread-group-added,id=\"i%d\"",
926 inf->num);
927 gdb_flush (mi->event_channel);
928 return 0;
929}
5796c8dc 930
a45ae5f8
JM
931static struct ui_out *
932mi_ui_out (struct interp *interp)
933{
934 struct mi_interp *mi = interp_data (interp);
935
936 return mi->uiout;
937}
938
ef5ccd6c
JM
939/* Save the original value of raw_stdout here when logging, so we can
940 restore correctly when done. */
941
942static struct ui_file *saved_raw_stdout;
943
944/* Do MI-specific logging actions; save raw_stdout, and change all
945 the consoles to use the supplied ui-file(s). */
946
947static int
948mi_set_logging (struct interp *interp, int start_log,
949 struct ui_file *out, struct ui_file *logfile)
950{
951 struct mi_interp *mi = interp_data (interp);
952
953 if (!mi)
954 return 0;
955
956 if (start_log)
957 {
958 /* The tee created already is based on gdb_stdout, which for MI
959 is a console and so we end up in an infinite loop of console
960 writing to ui_file writing to console etc. So discard the
961 existing tee (it hasn't been used yet, and MI won't ever use
962 it), and create one based on raw_stdout instead. */
963 if (logfile)
964 {
965 ui_file_delete (out);
966 out = tee_file_new (raw_stdout, 0, logfile, 0);
967 }
968
969 saved_raw_stdout = raw_stdout;
970 raw_stdout = out;
971 }
972 else
973 {
974 raw_stdout = saved_raw_stdout;
975 saved_raw_stdout = NULL;
976 }
977
978 mi_console_set_raw (mi->out, raw_stdout);
979 mi_console_set_raw (mi->err, raw_stdout);
980 mi_console_set_raw (mi->log, raw_stdout);
981 mi_console_set_raw (mi->targ, raw_stdout);
982 mi_console_set_raw (mi->event_channel, raw_stdout);
983
984 return 1;
985}
986
5796c8dc
SS
987extern initialize_file_ftype _initialize_mi_interp; /* -Wmissing-prototypes */
988
989void
990_initialize_mi_interp (void)
991{
992 static const struct interp_procs procs =
ef5ccd6c
JM
993 {
994 mi_interpreter_init, /* init_proc */
995 mi_interpreter_resume, /* resume_proc */
996 mi_interpreter_suspend, /* suspend_proc */
997 mi_interpreter_exec, /* exec_proc */
998 mi_interpreter_prompt_p, /* prompt_proc_p */
999 mi_ui_out, /* ui_out_proc */
1000 mi_set_logging /* set_logging_proc */
1001 };
5796c8dc
SS
1002
1003 /* The various interpreter levels. */
a45ae5f8
JM
1004 interp_add (interp_new (INTERP_MI1, &procs));
1005 interp_add (interp_new (INTERP_MI2, &procs));
1006 interp_add (interp_new (INTERP_MI3, &procs));
1007 interp_add (interp_new (INTERP_MI, &procs));
5796c8dc 1008}