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-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 
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, "@", '"');
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. */
136 
137  if (top_level)
138  {
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. */
167  }
168 
169  return mi;
170 }
171 
172 static int
174 {
175  struct mi_interp *mi = data;
176 
177  /* As per hack note in mi_interpreter_init, swap in the output
178  channels... */
180 
181  /* These overwrite some of the initialization done in
182  _intialize_event_loop. */
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... */
206 
208 
209  return 1;
210 }
211 
212 static int
214 {
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. */
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 
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
285 {
287 }
288 
289 static 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
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);
326  }
327 }
328 
329 /* mi_execute_command_wrapper wrapper suitable for INPUT_HANDLER. */
330 
331 static void
333 {
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);
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);
366 
367  start_event_loop ();
368 }
369 
370 static void
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 
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 
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
422 {
423  struct mi_interp *mi = top_level_interpreter_data ();
424 
427  "thread-group-added,id=\"i%d\"",
428  inf->num);
429  gdb_flush (mi->event_channel);
430 }
431 
432 static void
434 {
435  struct mi_interp *mi = top_level_interpreter_data ();
436 
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
446 {
447  struct mi_interp *mi = top_level_interpreter_data ();
448 
450  if (inf->has_exit_code)
452  "thread-group-exited,id=\"i%d\",exit-code=\"%s\"",
453  inf->num, int_string (inf->exit_code, 8, 0, 0, 1));
454  else
456  "thread-group-exited,id=\"i%d\"", inf->num);
457 
458  gdb_flush (mi->event_channel);
459 }
460 
461 static void
463 {
464  struct mi_interp *mi = top_level_interpreter_data ();
465 
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
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 *
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 *
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);
532 }
533 
534 /* Observer for the end_stepping_range notification. */
535 
536 static void
538 {
539  struct mi_interp *mi = mi_interp_data ();
540 
541  if (mi == NULL)
542  return;
543 
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
580 {
581  struct mi_interp *mi = mi_interp_data ();
582 
583  if (mi == NULL)
584  return;
585 
588 }
589 
590 static void
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
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. */
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",
671  if (non_stop)
672  {
674  (mi_uiout, "stopped-threads");
675 
676  ui_out_field_int (mi_uiout, NULL,
678  do_cleanups (back_to);
679  }
680  else
681  ui_out_field_string (mi_uiout, "stopped-threads", "all");
682 
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);
694 }
695 
696 static void
698 {
699  /* Suppress output while calling an inferior function. */
700 
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 
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
748 {
749  struct mi_interp *mi = top_level_interpreter_data ();
750 
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
764 {
765  struct mi_interp *mi = top_level_interpreter_data ();
766 
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
782 {
783  struct mi_interp *mi = top_level_interpreter_data ();
784  struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
785 
787 
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
808 {
809  struct mi_interp *mi = top_level_interpreter_data ();
810  struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
811 
812  if (mi_suppress_notification.breakpoint)
813  return;
814 
815  if (b->number <= 0)
816  return;
817 
820  "breakpoint-created");
821  /* We want the output from gdb_breakpoint_query to go to
822  mi->event_channel. One approach would be to just call
823  gdb_breakpoint_query, and then use mi_out_put to send the current
824  content of mi_outout into mi->event_channel. However, that will
825  break if anything is output to mi_uiout prior to calling the
826  breakpoint_created notifications. So, we use
827  ui_out_redirect. */
828  ui_out_redirect (mi_uiout, mi->event_channel);
829  TRY
830  {
831  gdb_breakpoint_query (mi_uiout, b->number, NULL);
832  }
834  {
835  }
836  END_CATCH
837 
838  ui_out_redirect (mi_uiout, NULL);
839 
840  gdb_flush (mi->event_channel);
841 }
842 
843 /* Emit notification about deleted breakpoint. */
844 
845 static void
847 {
848  struct mi_interp *mi = top_level_interpreter_data ();
849 
850  if (mi_suppress_notification.breakpoint)
851  return;
852 
853  if (b->number <= 0)
854  return;
855 
857 
858  fprintf_unfiltered (mi->event_channel, "breakpoint-deleted,id=\"%d\"",
859  b->number);
860 
861  gdb_flush (mi->event_channel);
862 }
863 
864 /* Emit notification about modified breakpoint. */
865 
866 static void
868 {
869  struct mi_interp *mi = top_level_interpreter_data ();
870  struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
871 
872  if (mi_suppress_notification.breakpoint)
873  return;
874 
875  if (b->number <= 0)
876  return;
877 
880  "breakpoint-modified");
881  /* We want the output from gdb_breakpoint_query to go to
882  mi->event_channel. One approach would be to just call
883  gdb_breakpoint_query, and then use mi_out_put to send the current
884  content of mi_outout into mi->event_channel. However, that will
885  break if anything is output to mi_uiout prior to calling the
886  breakpoint_created notifications. So, we use
887  ui_out_redirect. */
888  ui_out_redirect (mi_uiout, mi->event_channel);
889  TRY
890  {
891  gdb_breakpoint_query (mi_uiout, b->number, NULL);
892  }
894  {
895  }
896  END_CATCH
897 
898  ui_out_redirect (mi_uiout, NULL);
899 
900  gdb_flush (mi->event_channel);
901 }
902 
903 static int
904 mi_output_running_pid (struct thread_info *info, void *arg)
905 {
906  ptid_t *ptid = arg;
907 
908  if (ptid_get_pid (*ptid) == ptid_get_pid (info->ptid))
910  "*running,thread-id=\"%d\"\n",
911  info->num);
912 
913  return 0;
914 }
915 
916 static int
917 mi_inferior_count (struct inferior *inf, void *arg)
918 {
919  if (inf->pid != 0)
920  {
921  int *count_p = arg;
922  (*count_p)++;
923  }
924 
925  return 0;
926 }
927 
928 static void
930 {
931  struct thread_info *tp = NULL;
932 
933  if (ptid_equal (ptid, minus_one_ptid) || ptid_is_pid (ptid))
934  tp = inferior_thread ();
935  else
936  tp = find_thread_ptid (ptid);
937 
938  /* Suppress output while calling an inferior function. */
939  if (tp->control.in_infcall)
940  return;
941 
942  /* To cater for older frontends, emit ^running, but do it only once
943  per each command. We do it here, since at this point we know
944  that the target was successfully resumed, and in non-async mode,
945  we won't return back to MI interpreter code until the target
946  is done running, so delaying the output of "^running" until then
947  will make it impossible for frontend to know what's going on.
948 
949  In future (MI3), we'll be outputting "^done" here. */
951  {
952  fprintf_unfiltered (raw_stdout, "%s^running\n",
954  }
955 
956  if (ptid_get_pid (ptid) == -1)
957  fprintf_unfiltered (raw_stdout, "*running,thread-id=\"all\"\n");
958  else if (ptid_is_pid (ptid))
959  {
960  int count = 0;
961 
962  /* Backwards compatibility. If there's only one inferior,
963  output "all", otherwise, output each resumed thread
964  individually. */
966 
967  if (count == 1)
968  fprintf_unfiltered (raw_stdout, "*running,thread-id=\"all\"\n");
969  else
971  }
972  else
973  {
974  struct thread_info *ti = find_thread_ptid (ptid);
975 
976  gdb_assert (ti);
977  fprintf_unfiltered (raw_stdout, "*running,thread-id=\"%d\"\n", ti->num);
978  }
979 
981  {
983  /* This is what gdb used to do historically -- printing prompt even if
984  it cannot actually accept any input. This will be surely removed
985  for MI3, and may be removed even earlier. SYNC_EXECUTION is
986  checked here because we only need to emit a prompt if a
987  synchronous command was issued when the target is async. */
989  fputs_unfiltered ("(gdb) \n", raw_stdout);
990  }
992 }
993 
994 static void
995 mi_solib_loaded (struct so_list *solib)
996 {
997  struct mi_interp *mi = top_level_interpreter_data ();
998  struct ui_out *uiout = interp_ui_out (top_level_interpreter ());
999 
1001 
1002  fprintf_unfiltered (mi->event_channel, "library-loaded");
1003 
1004  ui_out_redirect (uiout, mi->event_channel);
1005 
1006  ui_out_field_string (uiout, "id", solib->so_original_name);
1007  ui_out_field_string (uiout, "target-name", solib->so_original_name);
1008  ui_out_field_string (uiout, "host-name", solib->so_name);
1009  ui_out_field_int (uiout, "symbols-loaded", solib->symbols_loaded);
1011  {
1012  ui_out_field_fmt (uiout, "thread-group", "i%d", current_inferior ()->num);
1013  }
1014 
1015  ui_out_redirect (uiout, NULL);
1016 
1017  gdb_flush (mi->event_channel);
1018 }
1019 
1020 static void
1022 {
1023  struct mi_interp *mi = top_level_interpreter_data ();
1024  struct ui_out *uiout = interp_ui_out (top_level_interpreter ());
1025 
1027 
1028  fprintf_unfiltered (mi->event_channel, "library-unloaded");
1029 
1030  ui_out_redirect (uiout, mi->event_channel);
1031 
1032  ui_out_field_string (uiout, "id", solib->so_original_name);
1033  ui_out_field_string (uiout, "target-name", solib->so_original_name);
1034  ui_out_field_string (uiout, "host-name", solib->so_name);
1036  {
1037  ui_out_field_fmt (uiout, "thread-group", "i%d", current_inferior ()->num);
1038  }
1039 
1040  ui_out_redirect (uiout, NULL);
1041 
1042  gdb_flush (mi->event_channel);
1043 }
1044 
1045 /* Emit notification about the command parameter change. */
1046 
1047 static void
1048 mi_command_param_changed (const char *param, const char *value)
1049 {
1050  struct mi_interp *mi = top_level_interpreter_data ();
1051  struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
1052 
1053  if (mi_suppress_notification.cmd_param_changed)
1054  return;
1055 
1057 
1059  "cmd-param-changed");
1060 
1061  ui_out_redirect (mi_uiout, mi->event_channel);
1062 
1063  ui_out_field_string (mi_uiout, "param", param);
1064  ui_out_field_string (mi_uiout, "value", value);
1065 
1066  ui_out_redirect (mi_uiout, NULL);
1067 
1068  gdb_flush (mi->event_channel);
1069 }
1070 
1071 /* Emit notification about the target memory change. */
1072 
1073 static void
1075  ssize_t len, const bfd_byte *myaddr)
1076 {
1077  struct mi_interp *mi = top_level_interpreter_data ();
1078  struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ());
1079  struct obj_section *sec;
1080 
1081  if (mi_suppress_notification.memory)
1082  return;
1083 
1085 
1087  "memory-changed");
1088 
1089  ui_out_redirect (mi_uiout, mi->event_channel);
1090 
1091  ui_out_field_fmt (mi_uiout, "thread-group", "i%d", inferior->num);
1092  ui_out_field_core_addr (mi_uiout, "addr", target_gdbarch (), memaddr);
1093  ui_out_field_fmt (mi_uiout, "len", "%s", hex_string (len));
1094 
1095  /* Append 'type=code' into notification if MEMADDR falls in the range of
1096  sections contain code. */
1097  sec = find_pc_section (memaddr);
1098  if (sec != NULL && sec->objfile != NULL)
1099  {
1100  flagword flags = bfd_get_section_flags (sec->objfile->obfd,
1101  sec->the_bfd_section);
1102 
1103  if (flags & SEC_CODE)
1104  ui_out_field_string (mi_uiout, "type", "code");
1105  }
1106 
1107  ui_out_redirect (mi_uiout, NULL);
1108 
1109  gdb_flush (mi->event_channel);
1110 }
1111 
1112 static int
1113 report_initial_inferior (struct inferior *inf, void *closure)
1114 {
1115  /* This function is called from mi_intepreter_init, and since
1116  mi_inferior_added assumes that inferior is fully initialized
1117  and top_level_interpreter_data is set, we cannot call
1118  it here. */
1119  struct mi_interp *mi = closure;
1120 
1123  "thread-group-added,id=\"i%d\"",
1124  inf->num);
1125  gdb_flush (mi->event_channel);
1126  return 0;
1127 }
1128 
1129 static struct ui_out *
1131 {
1132  struct mi_interp *mi = interp_data (interp);
1133 
1134  return mi->mi_uiout;
1135 }
1136 
1137 /* Save the original value of raw_stdout here when logging, so we can
1138  restore correctly when done. */
1139 
1140 static struct ui_file *saved_raw_stdout;
1141 
1142 /* Do MI-specific logging actions; save raw_stdout, and change all
1143  the consoles to use the supplied ui-file(s). */
1144 
1145 static int
1146 mi_set_logging (struct interp *interp, int start_log,
1147  struct ui_file *out, struct ui_file *logfile)
1148 {
1149  struct mi_interp *mi = interp_data (interp);
1150 
1151  if (!mi)
1152  return 0;
1153 
1154  if (start_log)
1155  {
1156  /* The tee created already is based on gdb_stdout, which for MI
1157  is a console and so we end up in an infinite loop of console
1158  writing to ui_file writing to console etc. So discard the
1159  existing tee (it hasn't been used yet, and MI won't ever use
1160  it), and create one based on raw_stdout instead. */
1161  if (logfile)
1162  {
1163  ui_file_delete (out);
1164  out = tee_file_new (raw_stdout, 0, logfile, 0);
1165  }
1166 
1167  saved_raw_stdout = raw_stdout;
1168  raw_stdout = out;
1169  }
1170  else
1171  {
1173  saved_raw_stdout = NULL;
1174  }
1175 
1181 
1182  return 1;
1183 }
1184 
1185 extern initialize_file_ftype _initialize_mi_interp; /* -Wmissing-prototypes */
1186 
1187 void
1189 {
1190  static const struct interp_procs procs =
1191  {
1192  mi_interpreter_init, /* init_proc */
1193  mi_interpreter_resume, /* resume_proc */
1194  mi_interpreter_suspend, /* suspend_proc */
1195  mi_interpreter_exec, /* exec_proc */
1196  mi_ui_out, /* ui_out_proc */
1197  mi_set_logging, /* set_logging_proc */
1198  mi_command_loop /* command_loop_proc */
1199  };
1200 
1201  /* The various interpreter levels. */
1202  interp_add (interp_new (INTERP_MI1, &procs));
1203  interp_add (interp_new (INTERP_MI2, &procs));
1204  interp_add (interp_new (INTERP_MI3, &procs));
1205  interp_add (interp_new (INTERP_MI, &procs));
1206 }
void get_last_target_status(ptid_t *ptidp, struct target_waitstatus *status)
Definition: infrun.c:3408
struct gdbarch * target_gdbarch(void)
Definition: gdbarch.c:5143
void target_terminal_ours(void)
Definition: target.c:491
static int mi_inferior_count(struct inferior *inf, void *arg)
Definition: mi-interp.c:917
Definition: interps.c:48
static void mi_inferior_exit(struct inferior *inf)
Definition: mi-interp.c:445
struct observer * observer_attach_record_changed(observer_record_changed_ftype *f)
void start_event_loop(void)
Definition: event-loop.c:335
static void mi_on_no_history(void)
Definition: mi-interp.c:579
struct observer * observer_attach_breakpoint_deleted(observer_breakpoint_deleted_ftype *f)
static void mi_on_end_stepping_range(void)
Definition: mi-interp.c:537
struct thread_info * find_thread_ptid(ptid_t ptid)
Definition: thread.c:393
struct observer * observer_attach_inferior_removed(observer_inferior_removed_ftype *f)
struct observer * observer_attach_thread_exit(observer_thread_exit_ftype *f)
bfd * obfd
Definition: objfiles.h:313
FILE * instream
Definition: top.c:109
int ptid_is_pid(ptid_t ptid)
Definition: ptid.c:86
static void mi_on_signal_exited(enum gdb_signal siggnal)
Definition: mi-interp.c:551
void ui_out_field_int(struct ui_out *uiout, const char *fldname, int value)
Definition: ui-out.c:467
int ptid_equal(ptid_t ptid1, ptid_t ptid2)
Definition: ptid.c:76
bfd_vma CORE_ADDR
Definition: common-types.h:41
void print_signal_received_reason(struct ui_out *uiout, enum gdb_signal siggnal)
Definition: infrun.c:6441
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:2341
static int mi_output_running_pid(struct thread_info *info, void *arg)
Definition: mi-interp.c:904
void fputs_unfiltered(const char *buf, struct ui_file *file)
Definition: ui-file.c:252
#define INTERP_MI2
Definition: interps.h:110
void xfree(void *)
Definition: common-utils.c:97
void(* input_handler)(char *)
Definition: event-top.c:97
void mi_console_set_raw(struct ui_file *file, struct ui_file *raw)
Definition: mi-console.c:145
void print_no_history_reason(struct ui_out *uiout)
Definition: infrun.c:6475
int gdbarch_has_global_solist(struct gdbarch *gdbarch)
Definition: gdbarch.c:4346
static int mi_set_logging(struct interp *interp, int start_log, struct ui_file *out, struct ui_file *logfile)
Definition: mi-interp.c:1146
int mi_proceeded
Definition: mi-main.c:93
struct bfd_section * the_bfd_section
Definition: objfiles.h:121
static int mi_interpreter_resume(void *data)
Definition: mi-interp.c:173
int(* deprecated_query_hook)(const char *, va_list) ATTRIBUTE_FPTR_PRINTF(1
Definition: top.c:191
tuple inf
Definition: arm-linux.py:13
char * current_token
Definition: mi-main.c:83
static void mi_new_thread(struct thread_info *t)
Definition: mi-interp.c:371
static struct interp * find_mi_interpreter(void)
Definition: mi-interp.c:488
void ui_file_delete(struct ui_file *file)
Definition: ui-file.c:76
static void mi_command_param_changed(const char *param, const char *value)
Definition: mi-interp.c:1048
struct ui_file * gdb_stdout
Definition: main.c:71
static void restore_current_uiout_cleanup(void *arg)
Definition: mi-interp.c:476
struct ui_out * cli_out_new(struct ui_file *stream)
Definition: cli-out.c:400
int pid
Definition: inferior.h:299
struct thread_info * inferior_thread(void)
Definition: thread.c:85
int num
Definition: inferior.h:295
static int mi_interpreter_suspend(void *data)
Definition: mi-interp.c:213
struct ui_out * interp_ui_out(struct interp *interp)
Definition: interps.c:229
int ui_out_is_mi_like_p(struct ui_out *uiout)
Definition: ui-out.c:655
struct observer * observer_attach_signal_exited(observer_signal_exited_ftype *f)
void mi_cmd_interpreter_exec(char *command, char **argv, int argc)
Definition: mi-interp.c:227
void print_exited_reason(struct ui_out *uiout, int exitstatus)
Definition: infrun.c:6408
const struct gdb_exception exception_none
#define INTERP_MI1
Definition: interps.h:109
static int report_initial_inferior(struct inferior *inf, void *closure)
Definition: mi-interp.c:1113
void gdb_setup_readline(void)
Definition: event-top.c:1036
Definition: solist.h:30
struct observer * observer_attach_inferior_exit(observer_inferior_exit_ftype *f)
struct inferior * find_inferior_ptid(ptid_t ptid)
Definition: inferior.c:373
struct inferior * iterate_over_inferiors(int(*callback)(struct inferior *, void *), void *data)
Definition: inferior.c:398
initialize_file_ftype _initialize_mi_interp
LONGEST exit_code
Definition: inferior.h:375
static void mi_on_exited(int exitstatus)
Definition: mi-interp.c:565
#define _(String)
Definition: gdb_locale.h:40
void gdb_disable_readline(void)
Definition: event-top.c:1094
#define INTERP_MI
Definition: interps.h:112
void interp_add(struct interp *interp)
Definition: interps.c:105
struct observer * observer_attach_signal_received(observer_signal_received_ftype *f)
#define END_CATCH
void ui_out_field_fmt(struct ui_out *uiout, const char *fldname, const char *format,...)
Definition: ui-out.c:556
static void mi_record_changed(struct inferior *, int)
Definition: mi-interp.c:410
Definition: ui-out.c:99
static void mi_on_sync_execution_done(void)
Definition: mi-interp.c:310
void mi_out_put(struct ui_out *uiout, struct ui_file *stream)
Definition: mi-out.c:380
static void mi_breakpoint_created(struct breakpoint *b)
Definition: mi-interp.c:807
static void mi_tsv_modified(const struct trace_state_variable *tsv)
Definition: mi-interp.c:781
Definition: ptid.h:35
static void mi_traceframe_changed(int tfnum, int tpnum)
Definition: mi-interp.c:725
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:1885
void null_cleanup(void *arg)
Definition: cleanups.c:295
#define TRY
struct thread_info * iterate_over_threads(thread_callback_func, void *)
Definition: thread.c:419
struct observer * observer_attach_no_history(observer_no_history_ftype *f)
void print_signal_exited_reason(struct ui_out *uiout, enum gdb_signal siggnal)
Definition: infrun.c:6387
struct observer * observer_attach_command_param_changed(observer_command_param_changed_ftype *f)
const char *const name
Definition: aarch64-tdep.c:68
void mi_print_timing_maybe(void)
Definition: mi-main.c:2464
static int static void mi_insert_notify_hooks(void)
Definition: mi-interp.c:284
void(* call_readline)(gdb_client_data)
Definition: event-top.c:98
#define CATCH(EXCEPTION, MASK)
static void mi_remove_notify_hooks(void)
Definition: mi-interp.c:290
static struct gdb_exception mi_interpreter_exec(void *data, const char *command)
Definition: mi-interp.c:220
void initialize_file_ftype(void)
Definition: defs.h:281
struct cleanup * make_cleanup_ui_out_list_begin_end(struct ui_out *uiout, const char *id)
Definition: ui-out.c:459
static int mi_interp_query_hook(const char *ctlstr, va_list ap) ATTRIBUTE_PRINTF(1
Definition: mi-interp.c:296
struct ui_out * cli_uiout
Definition: mi-common.h:64
static void mi_memory_changed(struct inferior *inf, CORE_ADDR memaddr, ssize_t len, const bfd_byte *myaddr)
Definition: mi-interp.c:1074
struct observer * observer_attach_tsv_created(observer_tsv_created_ftype *f)
void fprintf_unfiltered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2361
void clear_interpreter_hooks(void)
Definition: interps.c:363
struct observer * observer_attach_breakpoint_created(observer_breakpoint_created_ftype *f)
static void mi_on_resume(ptid_t ptid)
Definition: mi-interp.c:929
struct observer * observer_attach_solib_unloaded(observer_solib_unloaded_ftype *f)
struct ui_file * raw_stdout
Definition: mi-main.c:75
#define gdb_assert_not_reached(message)
Definition: gdb_assert.h:56
void * interp_data(struct interp *interp)
Definition: interps.c:265
char so_original_name[SO_NAME_MAX_PATH_SIZE]
Definition: solist.h:49
int async_command_editing_p
Definition: event-top.c:108
static void mi_inferior_added(struct inferior *inf)
Definition: mi-interp.c:421
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
Definition: cleanups.c:117
int sync_execution
Definition: infrun.c:117
char so_name[SO_NAME_MAX_PATH_SIZE]
Definition: solist.h:52
struct thread_control_state control
Definition: gdbthread.h:198
Definition: gnu-nat.c:163
static void mi_on_normal_stop(struct bpstats *bs, int print_frame)
Definition: mi-interp.c:591
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:71
#define gdb_assert(expr)
Definition: gdb_assert.h:33
static void * mi_interpreter_init(struct interp *interp, int top_level)
Definition: mi-interp.c:91
#define target_is_async_p()
Definition: target.h:1751
static void mi_thread_exit(struct thread_info *t, int silent)
Definition: mi-interp.c:385
struct observer * observer_attach_target_resumed(observer_target_resumed_ftype *f)
struct observer * observer_attach_exited(observer_exited_ftype *f)
static struct ui_file * saved_raw_stdout
Definition: mi-interp.c:1140
void mi_out_rewind(struct ui_out *uiout)
Definition: mi-out.c:370
struct ui_file * tee_file_new(struct ui_file *one, int close_one, struct ui_file *two, int close_two)
Definition: ui-file.c:750
struct interp * interp_new(const char *name, const struct interp_procs *procs)
Definition: interps.c:84
int running_result_record_printed
Definition: mi-main.c:89
void print_stop_event(struct target_waitstatus *ws)
Definition: infrun.c:6486
struct ui_file * log
Definition: mi-common.h:56
void gdb_readline2(gdb_client_data client_data)
Definition: event-top.c:710
struct obj_section * find_pc_section(CORE_ADDR pc)
Definition: objfiles.c:1337
struct observer * observer_attach_inferior_appeared(observer_inferior_appeared_ftype *f)
struct ui_file * gdb_stdlog
Definition: main.c:73
struct ui_out * mi_out_new(int mi_version)
Definition: mi-out.c:401
char symbols_loaded
Definition: solist.h:64
static void mi_tsv_deleted(const struct trace_state_variable *tsv)
Definition: mi-interp.c:763
static void mi_inferior_removed(struct inferior *inf)
Definition: mi-interp.c:462
struct interp * interp_lookup(const char *name)
Definition: interps.c:210
struct ui_file * targ
Definition: mi-common.h:57
Definition: value.c:172
int ptid_get_pid(ptid_t ptid)
Definition: ptid.c:52
const char * interp_name(struct interp *interp)
Definition: interps.c:273
static struct ui_out * mi_ui_out(struct interp *interp)
Definition: mi-interp.c:1130
static void mi_solib_unloaded(struct so_list *solib)
Definition: mi-interp.c:1021
static void mi_solib_loaded(struct so_list *solib)
Definition: mi-interp.c:995
static void mi_breakpoint_modified(struct breakpoint *b)
Definition: mi-interp.c:867
struct observer * observer_attach_tsv_modified(observer_tsv_modified_ftype *f)
static void mi_tsv_created(const struct trace_state_variable *tsv)
Definition: mi-interp.c:747
static void mi_breakpoint_deleted(struct breakpoint *b)
Definition: mi-interp.c:846
struct gdb_exception interp_exec(struct interp *interp, const char *command_str)
Definition: interps.c:342
static void print_frame(struct frame_info *frame, int print_level, enum print_what print_what, int print_args, struct symtab_and_line sal)
int non_stop
Definition: infrun.c:180
void print_end_stepping_range_reason(struct ui_out *uiout)
Definition: infrun.c:6375
void * top_level_interpreter_data(void)
Definition: interps.c:482
ptid_t null_ptid
Definition: ptid.c:25
ptid_t ptid
Definition: gdbthread.h:169
struct ui_out * mi_uiout
Definition: mi-common.h:61
int mi_version(struct ui_out *uiout)
Definition: mi-out.c:391
#define INTERP_MI3
Definition: interps.h:111
struct ui_file * gdb_stderr
Definition: main.c:72
ptid_t inferior_ptid
Definition: infcmd.c:124
struct observer * observer_attach_breakpoint_modified(observer_breakpoint_modified_ftype *f)
struct interp * command_interp(void)
Definition: interps.c:303
static void mi_on_signal_received(enum gdb_signal siggnal)
Definition: mi-interp.c:523
struct objfile * objfile
Definition: objfiles.h:124
struct ui_file * gdb_stdtarg
Definition: main.c:77
static void mi_about_to_proceed(void)
Definition: mi-interp.c:697
int target_core_of_thread(ptid_t ptid)
Definition: target.c:3442
enum gdb_rc gdb_breakpoint_query(struct ui_out *uiout, int bnum, char **error_message)
Definition: breakpoint.c:6626
struct inferior * current_inferior(void)
Definition: inferior.c:57
struct interp * command_interp
Definition: gdbthread.h:140
void ui_out_field_core_addr(struct ui_out *uiout, const char *fldname, struct gdbarch *gdbarch, CORE_ADDR address)
Definition: ui-out.c:499
int ui_out_redirect(struct ui_out *uiout, struct ui_file *outstream)
Definition: ui-out.c:612
struct ui_file * err
Definition: mi-common.h:55
static void ATTRIBUTE_PRINTF(6, 0)
Definition: cli-out.c:229
int has_exit_code
Definition: inferior.h:374
int pid_to_thread_id(ptid_t ptid)
Definition: thread.c:459
const char * message
struct observer * observer_attach_normal_stop(observer_normal_stop_ftype *f)
struct interp * top_level_interpreter(void)
Definition: interps.c:476
struct observer * observer_attach_new_thread(observer_new_thread_ftype *f)
void ui_out_field_string(struct ui_out *uiout, const char *fldname, const char *string)
Definition: ui-out.c:541
struct observer * observer_attach_inferior_added(observer_inferior_added_ftype *f)
struct ui_file * gdb_stdtargerr
Definition: main.c:78
static struct mi_interp * mi_interp_data(void)
Definition: mi-interp.c:507
struct observer * observer_attach_sync_execution_done(observer_sync_execution_done_ftype *f)
struct observer * observer_attach_end_stepping_range(observer_end_stepping_range_ftype *f)
void gdb_flush(struct ui_file *file)
Definition: ui-file.c:192
struct ui_out * current_uiout
Definition: ui-out.c:233
int mi_async_p(void)
Definition: mi-main.c:141
struct observer * observer_attach_memory_changed(observer_memory_changed_ftype *f)
struct ui_file * mi_console_file_new(struct ui_file *raw, const char *prefix, char quote)
Definition: mi-console.c:50
void mi_execute_command(const char *cmd, int from_tty)
Definition: mi-main.c:2091
static void mi_execute_command_input_handler(char *cmd)
Definition: mi-interp.c:332
void error(const char *fmt,...)
Definition: errors.c:38
int sevenbit_strings
ptid_t minus_one_ptid
Definition: ptid.c:26
struct ui_file * out
Definition: mi-common.h:54
struct observer * observer_attach_traceframe_changed(observer_traceframe_changed_ftype *f)
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:175
struct observer * observer_attach_tsv_deleted(observer_tsv_deleted_ftype *f)
struct observer * observer_attach_solib_loaded(observer_solib_loaded_ftype *f)
struct cleanup * make_cleanup_restore_target_terminal(void)
Definition: target.c:553
static void mi_execute_command_wrapper(const char *cmd)
Definition: mi-interp.c:302
enum return_reason reason
struct observer * observer_attach_about_to_proceed(observer_about_to_proceed_ftype *f)
static void mi_inferior_appeared(struct inferior *inf)
Definition: mi-interp.c:433
static void mi_command_loop(void *data)
Definition: mi-interp.c:357
const ULONGEST const LONGEST len
Definition: target.h:309
const char * name
Definition: tracepoint.h:49
struct ui_file * event_channel
Definition: mi-common.h:58