GDB (xrefs)
mi-main.c
Go to the documentation of this file.
1 /* MI Command Set.
2 
3  Copyright (C) 2000-2015 Free Software Foundation, Inc.
4 
5  Contributed by Cygnus Solutions (a Red Hat company).
6 
7  This file is part of GDB.
8 
9  This program is free software; you can redistribute it and/or modify
10  it under the terms of the GNU General Public License as published by
11  the Free Software Foundation; either version 3 of the License, or
12  (at your option) any later version.
13 
14  This program is distributed in the hope that it will be useful,
15  but WITHOUT ANY WARRANTY; without even the implied warranty of
16  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17  GNU General Public License for more details.
18 
19  You should have received a copy of the GNU General Public License
20  along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 
22 #include "defs.h"
23 #include "arch-utils.h"
24 #include "target.h"
25 #include "inferior.h"
26 #include "infrun.h"
27 #include "top.h"
28 #include "gdbthread.h"
29 #include "mi-cmds.h"
30 #include "mi-parse.h"
31 #include "mi-getopt.h"
32 #include "mi-console.h"
33 #include "ui-out.h"
34 #include "mi-out.h"
35 #include "interps.h"
36 #include "event-loop.h"
37 #include "event-top.h"
38 #include "gdbcore.h" /* For write_memory(). */
39 #include "value.h"
40 #include "regcache.h"
41 #include "gdb.h"
42 #include "frame.h"
43 #include "mi-main.h"
44 #include "mi-common.h"
45 #include "language.h"
46 #include "valprint.h"
47 #include "inferior.h"
48 #include "osdata.h"
49 #include "splay-tree.h"
50 #include "tracepoint.h"
51 #include "ctf.h"
52 #include "ada-lang.h"
53 #include "linespec.h"
54 #include "extension.h"
55 #include "gdbcmd.h"
56 
57 #include <ctype.h>
58 #include <sys/time.h>
59 
60 #if defined HAVE_SYS_RESOURCE_H
61 #include <sys/resource.h>
62 #endif
63 
64 #ifdef HAVE_GETRUSAGE
65 struct rusage rusage;
66 #endif
67 
68 enum
69  {
71  };
72 
74 
76 
77 /* This is used to pass the current command timestamp down to
78  continuation routines. */
80 
81 static int do_timings = 0;
82 
84 /* Few commands would like to know if options like --thread-group were
85  explicitly specified. This variable keeps the current parsed
86  command including all option, and make it possible. */
87 static struct mi_parse *current_context;
88 
90 
91 /* Flag indicating that the target has proceeded since the last
92  command was issued. */
94 
95 extern void _initialize_mi_main (void);
96 static void mi_cmd_execute (struct mi_parse *parse);
97 
98 static void mi_execute_cli_command (const char *cmd, int args_p,
99  const char *args);
100 static void mi_execute_async_cli_command (char *cli_command,
101  char **argv, int argc);
102 static int register_changed_p (int regnum, struct regcache *,
103  struct regcache *);
104 static void output_register (struct frame_info *, int regnum, int format,
105  int skip_unavailable);
106 
107 /* Controls whether the frontend wants MI in async mode. */
108 static int mi_async = 0;
109 
110 /* The set command writes to this variable. If the inferior is
111  executing, mi_async is *not* updated. */
112 static int mi_async_1 = 0;
113 
114 static void
115 set_mi_async_command (char *args, int from_tty,
116  struct cmd_list_element *c)
117 {
118  if (have_live_inferiors ())
119  {
120  mi_async_1 = mi_async;
121  error (_("Cannot change this setting while the inferior is running."));
122  }
123 
124  mi_async = mi_async_1;
125 }
126 
127 static void
128 show_mi_async_command (struct ui_file *file, int from_tty,
129  struct cmd_list_element *c,
130  const char *value)
131 {
132  fprintf_filtered (file,
133  _("Whether MI is in asynchronous mode is %s.\n"),
134  value);
135 }
136 
137 /* A wrapper for target_can_async_p that takes the MI setting into
138  account. */
139 
140 int
142 {
143  return mi_async && target_can_async_p ();
144 }
145 
146 /* Command implementations. FIXME: Is this libgdb? No. This is the MI
147  layer that calls libgdb. Any operation used in the below should be
148  formalized. */
149 
150 static void timestamp (struct mi_timestamp *tv);
151 
152 static void print_diff_now (struct mi_timestamp *start);
153 static void print_diff (struct mi_timestamp *start, struct mi_timestamp *end);
154 
155 void
156 mi_cmd_gdb_exit (char *command, char **argv, int argc)
157 {
158  /* We have to print everything right here because we never return. */
159  if (current_token)
160  fputs_unfiltered (current_token, raw_stdout);
161  fputs_unfiltered ("^exit\n", raw_stdout);
162  mi_out_put (current_uiout, raw_stdout);
163  gdb_flush (raw_stdout);
164  /* FIXME: The function called is not yet a formal libgdb function. */
165  quit_force (NULL, FROM_TTY);
166 }
167 
168 void
169 mi_cmd_exec_next (char *command, char **argv, int argc)
170 {
171  /* FIXME: Should call a libgdb function, not a cli wrapper. */
172  if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
173  mi_execute_async_cli_command ("reverse-next", argv + 1, argc - 1);
174  else
175  mi_execute_async_cli_command ("next", argv, argc);
176 }
177 
178 void
180 {
181  /* FIXME: Should call a libgdb function, not a cli wrapper. */
182  if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
183  mi_execute_async_cli_command ("reverse-nexti", argv + 1, argc - 1);
184  else
185  mi_execute_async_cli_command ("nexti", argv, argc);
186 }
187 
188 void
189 mi_cmd_exec_step (char *command, char **argv, int argc)
190 {
191  /* FIXME: Should call a libgdb function, not a cli wrapper. */
192  if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
193  mi_execute_async_cli_command ("reverse-step", argv + 1, argc - 1);
194  else
195  mi_execute_async_cli_command ("step", argv, argc);
196 }
197 
198 void
200 {
201  /* FIXME: Should call a libgdb function, not a cli wrapper. */
202  if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
203  mi_execute_async_cli_command ("reverse-stepi", argv + 1, argc - 1);
204  else
205  mi_execute_async_cli_command ("stepi", argv, argc);
206 }
207 
208 void
209 mi_cmd_exec_finish (char *command, char **argv, int argc)
210 {
211  /* FIXME: Should call a libgdb function, not a cli wrapper. */
212  if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
213  mi_execute_async_cli_command ("reverse-finish", argv + 1, argc - 1);
214  else
215  mi_execute_async_cli_command ("finish", argv, argc);
216 }
217 
218 void
219 mi_cmd_exec_return (char *command, char **argv, int argc)
220 {
221  /* This command doesn't really execute the target, it just pops the
222  specified number of frames. */
223  if (argc)
224  /* Call return_command with from_tty argument equal to 0 so as to
225  avoid being queried. */
226  return_command (*argv, 0);
227  else
228  /* Call return_command with from_tty argument equal to 0 so as to
229  avoid being queried. */
230  return_command (NULL, 0);
231 
232  /* Because we have called return_command with from_tty = 0, we need
233  to print the frame here. */
235 }
236 
237 void
238 mi_cmd_exec_jump (char *args, char **argv, int argc)
239 {
240  /* FIXME: Should call a libgdb function, not a cli wrapper. */
241  mi_execute_async_cli_command ("jump", argv, argc);
242 }
243 
244 static void
246 {
247  if (!is_stopped (thread->ptid))
248  return;
249 
250  if (pid != 0 && ptid_get_pid (thread->ptid) != pid)
251  return;
252 
253  switch_to_thread (thread->ptid);
255  proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT);
256 }
257 
258 static int
260 {
261  int pid = *(int *)arg;
262 
263  proceed_thread (thread, pid);
264  return 0;
265 }
266 
267 static void
268 exec_continue (char **argv, int argc)
269 {
271 
272  if (non_stop)
273  {
274  /* In non-stop mode, 'resume' always resumes a single thread.
275  Therefore, to resume all threads of the current inferior, or
276  all threads in all inferiors, we need to iterate over
277  threads.
278 
279  See comment on infcmd.c:proceed_thread_callback for rationale. */
280  if (current_context->all || current_context->thread_group != -1)
281  {
282  int pid = 0;
283  struct cleanup *back_to = make_cleanup_restore_current_thread ();
284 
285  if (!current_context->all)
286  {
287  struct inferior *inf
288  = find_inferior_id (current_context->thread_group);
289 
290  pid = inf->pid;
291  }
293  do_cleanups (back_to);
294  }
295  else
296  {
297  continue_1 (0);
298  }
299  }
300  else
301  {
302  struct cleanup *back_to = make_cleanup_restore_integer (&sched_multi);
303 
304  if (current_context->all)
305  {
306  sched_multi = 1;
307  continue_1 (0);
308  }
309  else
310  {
311  /* In all-stop mode, -exec-continue traditionally resumed
312  either all threads, or one thread, depending on the
313  'scheduler-locking' variable. Let's continue to do the
314  same. */
315  continue_1 (1);
316  }
317  do_cleanups (back_to);
318  }
319 }
320 
321 static void
322 exec_direction_forward (void *notused)
323 {
325 }
326 
327 static void
328 exec_reverse_continue (char **argv, int argc)
329 {
331  struct cleanup *old_chain;
332 
333  if (dir == EXEC_REVERSE)
334  error (_("Already in reverse mode."));
335 
337  error (_("Target %s does not support this command."), target_shortname);
338 
339  old_chain = make_cleanup (exec_direction_forward, NULL);
341  exec_continue (argv, argc);
342  do_cleanups (old_chain);
343 }
344 
345 void
346 mi_cmd_exec_continue (char *command, char **argv, int argc)
347 {
348  if (argc > 0 && strcmp (argv[0], "--reverse") == 0)
349  exec_reverse_continue (argv + 1, argc - 1);
350  else
351  exec_continue (argv, argc);
352 }
353 
354 static int
356 {
357  int pid = *(int *)arg;
358 
359  if (!is_running (thread->ptid))
360  return 0;
361 
362  if (ptid_get_pid (thread->ptid) != pid)
363  return 0;
364 
365  target_stop (thread->ptid);
366  return 0;
367 }
368 
369 /* Interrupt the execution of the target. Note how we must play
370  around with the token variables, in order to display the current
371  token in the result of the interrupt command, and the previous
372  execution token when the target finally stops. See comments in
373  mi_cmd_execute. */
374 
375 void
376 mi_cmd_exec_interrupt (char *command, char **argv, int argc)
377 {
378  /* In all-stop mode, everything stops, so we don't need to try
379  anything specific. */
380  if (!non_stop)
381  {
382  interrupt_target_1 (0);
383  return;
384  }
385 
386  if (current_context->all)
387  {
388  /* This will interrupt all threads in all inferiors. */
389  interrupt_target_1 (1);
390  }
391  else if (current_context->thread_group != -1)
392  {
393  struct inferior *inf = find_inferior_id (current_context->thread_group);
394 
396  }
397  else
398  {
399  /* Interrupt just the current thread -- either explicitly
400  specified via --thread or whatever was current before
401  MI command was sent. */
402  interrupt_target_1 (0);
403  }
404 }
405 
406 /* Callback for iterate_over_inferiors which starts the execution
407  of the given inferior.
408 
409  ARG is a pointer to an integer whose value, if non-zero, indicates
410  that the program should be stopped when reaching the main subprogram
411  (similar to what the CLI "start" command does). */
412 
413 static int
414 run_one_inferior (struct inferior *inf, void *arg)
415 {
416  int start_p = *(int *) arg;
417  const char *run_cmd = start_p ? "start" : "run";
418 
419  if (inf->pid != 0)
420  {
421  if (inf->pid != ptid_get_pid (inferior_ptid))
422  {
423  struct thread_info *tp;
424 
425  tp = any_thread_of_process (inf->pid);
426  if (!tp)
427  error (_("Inferior has no threads."));
428 
429  switch_to_thread (tp->ptid);
430  }
431  }
432  else
433  {
434  set_current_inferior (inf);
437  }
438  mi_execute_cli_command (run_cmd, mi_async_p (),
439  mi_async_p () ? "&" : NULL);
440  return 0;
441 }
442 
443 void
444 mi_cmd_exec_run (char *command, char **argv, int argc)
445 {
446  int i;
447  int start_p = 0;
448 
449  /* Parse the command options. */
450  enum opt
451  {
452  START_OPT,
453  };
454  static const struct mi_opt opts[] =
455  {
456  {"-start", START_OPT, 0},
457  {NULL, 0, 0},
458  };
459 
460  int oind = 0;
461  char *oarg;
462 
463  while (1)
464  {
465  int opt = mi_getopt ("-exec-run", argc, argv, opts, &oind, &oarg);
466 
467  if (opt < 0)
468  break;
469  switch ((enum opt) opt)
470  {
471  case START_OPT:
472  start_p = 1;
473  break;
474  }
475  }
476 
477  /* This command does not accept any argument. Make sure the user
478  did not provide any. */
479  if (oind != argc)
480  error (_("Invalid argument: %s"), argv[oind]);
481 
482  if (current_context->all)
483  {
484  struct cleanup *back_to = save_current_space_and_thread ();
485 
487  do_cleanups (back_to);
488  }
489  else
490  {
491  const char *run_cmd = start_p ? "start" : "run";
492 
493  mi_execute_cli_command (run_cmd, mi_async_p (),
494  mi_async_p () ? "&" : NULL);
495  }
496 }
497 
498 
499 static int
500 find_thread_of_process (struct thread_info *ti, void *p)
501 {
502  int pid = *(int *)p;
503 
504  if (ptid_get_pid (ti->ptid) == pid && !is_exited (ti->ptid))
505  return 1;
506 
507  return 0;
508 }
509 
510 void
511 mi_cmd_target_detach (char *command, char **argv, int argc)
512 {
513  if (argc != 0 && argc != 1)
514  error (_("Usage: -target-detach [pid | thread-group]"));
515 
516  if (argc == 1)
517  {
518  struct thread_info *tp;
519  char *end = argv[0];
520  int pid;
521 
522  /* First see if we are dealing with a thread-group id. */
523  if (*argv[0] == 'i')
524  {
525  struct inferior *inf;
526  int id = strtoul (argv[0] + 1, &end, 0);
527 
528  if (*end != '\0')
529  error (_("Invalid syntax of thread-group id '%s'"), argv[0]);
530 
531  inf = find_inferior_id (id);
532  if (!inf)
533  error (_("Non-existent thread-group id '%d'"), id);
534 
535  pid = inf->pid;
536  }
537  else
538  {
539  /* We must be dealing with a pid. */
540  pid = strtol (argv[0], &end, 10);
541 
542  if (*end != '\0')
543  error (_("Invalid identifier '%s'"), argv[0]);
544  }
545 
546  /* Pick any thread in the desired process. Current
547  target_detach detaches from the parent of inferior_ptid. */
549  if (!tp)
550  error (_("Thread group is empty"));
551 
552  switch_to_thread (tp->ptid);
553  }
554 
555  detach_command (NULL, 0);
556 }
557 
558 void
559 mi_cmd_thread_select (char *command, char **argv, int argc)
560 {
561  enum gdb_rc rc;
562  char *mi_error_message;
563 
564  if (argc != 1)
565  error (_("-thread-select: USAGE: threadnum."));
566 
567  rc = gdb_thread_select (current_uiout, argv[0], &mi_error_message);
568 
569  if (rc == GDB_RC_FAIL)
570  {
571  make_cleanup (xfree, mi_error_message);
572  error ("%s", mi_error_message);
573  }
574 }
575 
576 void
577 mi_cmd_thread_list_ids (char *command, char **argv, int argc)
578 {
579  enum gdb_rc rc;
580  char *mi_error_message;
581 
582  if (argc != 0)
583  error (_("-thread-list-ids: No arguments required."));
584 
585  rc = gdb_list_thread_ids (current_uiout, &mi_error_message);
586 
587  if (rc == GDB_RC_FAIL)
588  {
589  make_cleanup (xfree, mi_error_message);
590  error ("%s", mi_error_message);
591  }
592 }
593 
594 void
595 mi_cmd_thread_info (char *command, char **argv, int argc)
596 {
597  if (argc != 0 && argc != 1)
598  error (_("Invalid MI command"));
599 
600  print_thread_info (current_uiout, argv[0], -1);
601 }
602 
604 {
605  int pid;
606 
607  VEC (int) *cores;
608 };
609 
610 static int
611 collect_cores (struct thread_info *ti, void *xdata)
612 {
613  struct collect_cores_data *data = xdata;
614 
615  if (ptid_get_pid (ti->ptid) == data->pid)
616  {
617  int core = target_core_of_thread (ti->ptid);
618 
619  if (core != -1)
620  VEC_safe_push (int, data->cores, core);
621  }
622 
623  return 0;
624 }
625 
626 static int *
627 unique (int *b, int *e)
628 {
629  int *d = b;
630 
631  while (++b != e)
632  if (*d != *b)
633  *++d = *b;
634  return ++d;
635 }
636 
638 {
639  int recurse;
640  VEC (int) *inferiors;
641 };
642 
643 static int
644 print_one_inferior (struct inferior *inferior, void *xdata)
645 {
646  struct print_one_inferior_data *top_data = xdata;
647  struct ui_out *uiout = current_uiout;
648 
649  if (VEC_empty (int, top_data->inferiors)
650  || bsearch (&(inferior->pid), VEC_address (int, top_data->inferiors),
651  VEC_length (int, top_data->inferiors), sizeof (int),
653  {
654  struct collect_cores_data data;
655  struct cleanup *back_to
656  = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
657 
658  ui_out_field_fmt (uiout, "id", "i%d", inferior->num);
659  ui_out_field_string (uiout, "type", "process");
660  if (inferior->has_exit_code)
661  ui_out_field_string (uiout, "exit-code",
662  int_string (inferior->exit_code, 8, 0, 0, 1));
663  if (inferior->pid != 0)
664  ui_out_field_int (uiout, "pid", inferior->pid);
665 
666  if (inferior->pspace->pspace_exec_filename != NULL)
667  {
668  ui_out_field_string (uiout, "executable",
669  inferior->pspace->pspace_exec_filename);
670  }
671 
672  data.cores = 0;
673  if (inferior->pid != 0)
674  {
675  data.pid = inferior->pid;
677  }
678 
679  if (!VEC_empty (int, data.cores))
680  {
681  int *b, *e;
682  struct cleanup *back_to_2 =
683  make_cleanup_ui_out_list_begin_end (uiout, "cores");
684 
685  qsort (VEC_address (int, data.cores),
686  VEC_length (int, data.cores), sizeof (int),
688 
689  b = VEC_address (int, data.cores);
690  e = b + VEC_length (int, data.cores);
691  e = unique (b, e);
692 
693  for (; b != e; ++b)
694  ui_out_field_int (uiout, NULL, *b);
695 
696  do_cleanups (back_to_2);
697  }
698 
699  if (top_data->recurse)
700  print_thread_info (uiout, NULL, inferior->pid);
701 
702  do_cleanups (back_to);
703  }
704 
705  return 0;
706 }
707 
708 /* Output a field named 'cores' with a list as the value. The
709  elements of the list are obtained by splitting 'cores' on
710  comma. */
711 
712 static void
713 output_cores (struct ui_out *uiout, const char *field_name, const char *xcores)
714 {
715  struct cleanup *back_to = make_cleanup_ui_out_list_begin_end (uiout,
716  field_name);
717  char *cores = xstrdup (xcores);
718  char *p = cores;
719 
720  make_cleanup (xfree, cores);
721 
722  for (p = strtok (p, ","); p; p = strtok (NULL, ","))
723  ui_out_field_string (uiout, NULL, p);
724 
725  do_cleanups (back_to);
726 }
727 
728 static void
729 free_vector_of_ints (void *xvector)
730 {
731  VEC (int) **vector = xvector;
732 
733  VEC_free (int, *vector);
734 }
735 
736 static void
737 do_nothing (splay_tree_key k)
738 {
739 }
740 
741 static void
742 free_vector_of_osdata_items (splay_tree_value xvalue)
743 {
744  VEC (osdata_item_s) *value = (VEC (osdata_item_s) *) xvalue;
745 
746  /* We don't free the items itself, it will be done separately. */
748 }
749 
750 static int
751 splay_tree_int_comparator (splay_tree_key xa, splay_tree_key xb)
752 {
753  int a = xa;
754  int b = xb;
755 
756  return a - b;
757 }
758 
759 static void
760 free_splay_tree (void *xt)
761 {
762  splay_tree t = xt;
763  splay_tree_delete (t);
764 }
765 
766 static void
767 list_available_thread_groups (VEC (int) *ids, int recurse)
768 {
769  struct osdata *data;
770  struct osdata_item *item;
771  int ix_items;
772  struct ui_out *uiout = current_uiout;
773  struct cleanup *cleanup;
774 
775  /* This keeps a map from integer (pid) to VEC (struct osdata_item *)*
776  The vector contains information about all threads for the given pid.
777  This is assigned an initial value to avoid "may be used uninitialized"
778  warning from gcc. */
779  splay_tree tree = NULL;
780 
781  /* get_osdata will throw if it cannot return data. */
782  data = get_osdata ("processes");
783  cleanup = make_cleanup_osdata_free (data);
784 
785  if (recurse)
786  {
787  struct osdata *threads = get_osdata ("threads");
788 
789  make_cleanup_osdata_free (threads);
790  tree = splay_tree_new (splay_tree_int_comparator,
791  do_nothing,
794 
795  for (ix_items = 0;
796  VEC_iterate (osdata_item_s, threads->items,
797  ix_items, item);
798  ix_items++)
799  {
800  const char *pid = get_osdata_column (item, "pid");
801  int pid_i = strtoul (pid, NULL, 0);
802  VEC (osdata_item_s) *vec = 0;
803 
804  splay_tree_node n = splay_tree_lookup (tree, pid_i);
805  if (!n)
806  {
807  VEC_safe_push (osdata_item_s, vec, item);
808  splay_tree_insert (tree, pid_i, (splay_tree_value)vec);
809  }
810  else
811  {
812  vec = (VEC (osdata_item_s) *) n->value;
813  VEC_safe_push (osdata_item_s, vec, item);
814  n->value = (splay_tree_value) vec;
815  }
816  }
817  }
818 
819  make_cleanup_ui_out_list_begin_end (uiout, "groups");
820 
821  for (ix_items = 0;
822  VEC_iterate (osdata_item_s, data->items,
823  ix_items, item);
824  ix_items++)
825  {
826  struct cleanup *back_to;
827 
828  const char *pid = get_osdata_column (item, "pid");
829  const char *cmd = get_osdata_column (item, "command");
830  const char *user = get_osdata_column (item, "user");
831  const char *cores = get_osdata_column (item, "cores");
832 
833  int pid_i = strtoul (pid, NULL, 0);
834 
835  /* At present, the target will return all available processes
836  and if information about specific ones was required, we filter
837  undesired processes here. */
838  if (ids && bsearch (&pid_i, VEC_address (int, ids),
839  VEC_length (int, ids),
840  sizeof (int), compare_positive_ints) == NULL)
841  continue;
842 
843 
844  back_to = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
845 
846  ui_out_field_fmt (uiout, "id", "%s", pid);
847  ui_out_field_string (uiout, "type", "process");
848  if (cmd)
849  ui_out_field_string (uiout, "description", cmd);
850  if (user)
851  ui_out_field_string (uiout, "user", user);
852  if (cores)
853  output_cores (uiout, "cores", cores);
854 
855  if (recurse)
856  {
857  splay_tree_node n = splay_tree_lookup (tree, pid_i);
858  if (n)
859  {
860  VEC (osdata_item_s) *children = (VEC (osdata_item_s) *) n->value;
861  struct osdata_item *child;
862  int ix_child;
863 
864  make_cleanup_ui_out_list_begin_end (uiout, "threads");
865 
866  for (ix_child = 0;
867  VEC_iterate (osdata_item_s, children, ix_child, child);
868  ++ix_child)
869  {
870  struct cleanup *back_to_2 =
872  const char *tid = get_osdata_column (child, "tid");
873  const char *tcore = get_osdata_column (child, "core");
874 
875  ui_out_field_string (uiout, "id", tid);
876  if (tcore)
877  ui_out_field_string (uiout, "core", tcore);
878 
879  do_cleanups (back_to_2);
880  }
881  }
882  }
883 
884  do_cleanups (back_to);
885  }
886 
887  do_cleanups (cleanup);
888 }
889 
890 void
891 mi_cmd_list_thread_groups (char *command, char **argv, int argc)
892 {
893  struct ui_out *uiout = current_uiout;
894  struct cleanup *back_to;
895  int available = 0;
896  int recurse = 0;
897  VEC (int) *ids = 0;
898 
899  enum opt
900  {
901  AVAILABLE_OPT, RECURSE_OPT
902  };
903  static const struct mi_opt opts[] =
904  {
905  {"-available", AVAILABLE_OPT, 0},
906  {"-recurse", RECURSE_OPT, 1},
907  { 0, 0, 0 }
908  };
909 
910  int oind = 0;
911  char *oarg;
912 
913  while (1)
914  {
915  int opt = mi_getopt ("-list-thread-groups", argc, argv, opts,
916  &oind, &oarg);
917 
918  if (opt < 0)
919  break;
920  switch ((enum opt) opt)
921  {
922  case AVAILABLE_OPT:
923  available = 1;
924  break;
925  case RECURSE_OPT:
926  if (strcmp (oarg, "0") == 0)
927  ;
928  else if (strcmp (oarg, "1") == 0)
929  recurse = 1;
930  else
931  error (_("only '0' and '1' are valid values "
932  "for the '--recurse' option"));
933  break;
934  }
935  }
936 
937  for (; oind < argc; ++oind)
938  {
939  char *end;
940  int inf;
941 
942  if (*(argv[oind]) != 'i')
943  error (_("invalid syntax of group id '%s'"), argv[oind]);
944 
945  inf = strtoul (argv[oind] + 1, &end, 0);
946 
947  if (*end != '\0')
948  error (_("invalid syntax of group id '%s'"), argv[oind]);
949  VEC_safe_push (int, ids, inf);
950  }
951  if (VEC_length (int, ids) > 1)
952  qsort (VEC_address (int, ids),
953  VEC_length (int, ids),
954  sizeof (int), compare_positive_ints);
955 
956  back_to = make_cleanup (free_vector_of_ints, &ids);
957 
958  if (available)
959  {
960  list_available_thread_groups (ids, recurse);
961  }
962  else if (VEC_length (int, ids) == 1)
963  {
964  /* Local thread groups, single id. */
965  int id = *VEC_address (int, ids);
966  struct inferior *inf = find_inferior_id (id);
967 
968  if (!inf)
969  error (_("Non-existent thread group id '%d'"), id);
970 
971  print_thread_info (uiout, NULL, inf->pid);
972  }
973  else
974  {
975  struct print_one_inferior_data data;
976 
977  data.recurse = recurse;
978  data.inferiors = ids;
979 
980  /* Local thread groups. Either no explicit ids -- and we
981  print everything, or several explicit ids. In both cases,
982  we print more than one group, and have to use 'groups'
983  as the top-level element. */
984  make_cleanup_ui_out_list_begin_end (uiout, "groups");
987  }
988 
989  do_cleanups (back_to);
990 }
991 
992 void
993 mi_cmd_data_list_register_names (char *command, char **argv, int argc)
994 {
995  struct gdbarch *gdbarch;
996  struct ui_out *uiout = current_uiout;
997  int regnum, numregs;
998  int i;
999  struct cleanup *cleanup;
1000 
1001  /* Note that the test for a valid register must include checking the
1002  gdbarch_register_name because gdbarch_num_regs may be allocated
1003  for the union of the register sets within a family of related
1004  processors. In this case, some entries of gdbarch_register_name
1005  will change depending upon the particular processor being
1006  debugged. */
1007 
1008  gdbarch = get_current_arch ();
1009  numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
1010 
1011  cleanup = make_cleanup_ui_out_list_begin_end (uiout, "register-names");
1012 
1013  if (argc == 0) /* No args, just do all the regs. */
1014  {
1015  for (regnum = 0;
1016  regnum < numregs;
1017  regnum++)
1018  {
1019  if (gdbarch_register_name (gdbarch, regnum) == NULL
1020  || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
1021  ui_out_field_string (uiout, NULL, "");
1022  else
1023  ui_out_field_string (uiout, NULL,
1024  gdbarch_register_name (gdbarch, regnum));
1025  }
1026  }
1027 
1028  /* Else, list of register #s, just do listed regs. */
1029  for (i = 0; i < argc; i++)
1030  {
1031  regnum = atoi (argv[i]);
1032  if (regnum < 0 || regnum >= numregs)
1033  error (_("bad register number"));
1034 
1035  if (gdbarch_register_name (gdbarch, regnum) == NULL
1036  || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
1037  ui_out_field_string (uiout, NULL, "");
1038  else
1039  ui_out_field_string (uiout, NULL,
1040  gdbarch_register_name (gdbarch, regnum));
1041  }
1042  do_cleanups (cleanup);
1043 }
1044 
1045 void
1046 mi_cmd_data_list_changed_registers (char *command, char **argv, int argc)
1047 {
1048  static struct regcache *this_regs = NULL;
1049  struct ui_out *uiout = current_uiout;
1050  struct regcache *prev_regs;
1051  struct gdbarch *gdbarch;
1052  int regnum, numregs, changed;
1053  int i;
1054  struct cleanup *cleanup;
1055 
1056  /* The last time we visited this function, the current frame's
1057  register contents were saved in THIS_REGS. Move THIS_REGS over
1058  to PREV_REGS, and refresh THIS_REGS with the now-current register
1059  contents. */
1060 
1061  prev_regs = this_regs;
1062  this_regs = frame_save_as_regcache (get_selected_frame (NULL));
1063  cleanup = make_cleanup_regcache_xfree (prev_regs);
1064 
1065  /* Note that the test for a valid register must include checking the
1066  gdbarch_register_name because gdbarch_num_regs may be allocated
1067  for the union of the register sets within a family of related
1068  processors. In this case, some entries of gdbarch_register_name
1069  will change depending upon the particular processor being
1070  debugged. */
1071 
1072  gdbarch = get_regcache_arch (this_regs);
1073  numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
1074 
1075  make_cleanup_ui_out_list_begin_end (uiout, "changed-registers");
1076 
1077  if (argc == 0)
1078  {
1079  /* No args, just do all the regs. */
1080  for (regnum = 0;
1081  regnum < numregs;
1082  regnum++)
1083  {
1084  if (gdbarch_register_name (gdbarch, regnum) == NULL
1085  || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
1086  continue;
1087  changed = register_changed_p (regnum, prev_regs, this_regs);
1088  if (changed < 0)
1089  error (_("-data-list-changed-registers: "
1090  "Unable to read register contents."));
1091  else if (changed)
1092  ui_out_field_int (uiout, NULL, regnum);
1093  }
1094  }
1095 
1096  /* Else, list of register #s, just do listed regs. */
1097  for (i = 0; i < argc; i++)
1098  {
1099  regnum = atoi (argv[i]);
1100 
1101  if (regnum >= 0
1102  && regnum < numregs
1103  && gdbarch_register_name (gdbarch, regnum) != NULL
1104  && *gdbarch_register_name (gdbarch, regnum) != '\000')
1105  {
1106  changed = register_changed_p (regnum, prev_regs, this_regs);
1107  if (changed < 0)
1108  error (_("-data-list-changed-registers: "
1109  "Unable to read register contents."));
1110  else if (changed)
1111  ui_out_field_int (uiout, NULL, regnum);
1112  }
1113  else
1114  error (_("bad register number"));
1115  }
1116  do_cleanups (cleanup);
1117 }
1118 
1119 static int
1120 register_changed_p (int regnum, struct regcache *prev_regs,
1121  struct regcache *this_regs)
1122 {
1123  struct gdbarch *gdbarch = get_regcache_arch (this_regs);
1124  gdb_byte prev_buffer[MAX_REGISTER_SIZE];
1125  gdb_byte this_buffer[MAX_REGISTER_SIZE];
1126  enum register_status prev_status;
1127  enum register_status this_status;
1128 
1129  /* First time through or after gdbarch change consider all registers
1130  as changed. */
1131  if (!prev_regs || get_regcache_arch (prev_regs) != gdbarch)
1132  return 1;
1133 
1134  /* Get register contents and compare. */
1135  prev_status = regcache_cooked_read (prev_regs, regnum, prev_buffer);
1136  this_status = regcache_cooked_read (this_regs, regnum, this_buffer);
1137 
1138  if (this_status != prev_status)
1139  return 1;
1140  else if (this_status == REG_VALID)
1141  return memcmp (prev_buffer, this_buffer,
1142  register_size (gdbarch, regnum)) != 0;
1143  else
1144  return 0;
1145 }
1146 
1147 /* Return a list of register number and value pairs. The valid
1148  arguments expected are: a letter indicating the format in which to
1149  display the registers contents. This can be one of: x
1150  (hexadecimal), d (decimal), N (natural), t (binary), o (octal), r
1151  (raw). After the format argument there can be a sequence of
1152  numbers, indicating which registers to fetch the content of. If
1153  the format is the only argument, a list of all the registers with
1154  their values is returned. */
1155 
1156 void
1157 mi_cmd_data_list_register_values (char *command, char **argv, int argc)
1158 {
1159  struct ui_out *uiout = current_uiout;
1160  struct frame_info *frame;
1161  struct gdbarch *gdbarch;
1162  int regnum, numregs, format;
1163  int i;
1164  struct cleanup *list_cleanup;
1165  int skip_unavailable = 0;
1166  int oind = 0;
1167  enum opt
1168  {
1169  SKIP_UNAVAILABLE,
1170  };
1171  static const struct mi_opt opts[] =
1172  {
1173  {"-skip-unavailable", SKIP_UNAVAILABLE, 0},
1174  { 0, 0, 0 }
1175  };
1176 
1177  /* Note that the test for a valid register must include checking the
1178  gdbarch_register_name because gdbarch_num_regs may be allocated
1179  for the union of the register sets within a family of related
1180  processors. In this case, some entries of gdbarch_register_name
1181  will change depending upon the particular processor being
1182  debugged. */
1183 
1184  while (1)
1185  {
1186  char *oarg;
1187  int opt = mi_getopt ("-data-list-register-values", argc, argv,
1188  opts, &oind, &oarg);
1189 
1190  if (opt < 0)
1191  break;
1192  switch ((enum opt) opt)
1193  {
1194  case SKIP_UNAVAILABLE:
1195  skip_unavailable = 1;
1196  break;
1197  }
1198  }
1199 
1200  if (argc - oind < 1)
1201  error (_("-data-list-register-values: Usage: "
1202  "-data-list-register-values [--skip-unavailable] <format>"
1203  " [<regnum1>...<regnumN>]"));
1204 
1205  format = (int) argv[oind][0];
1206 
1207  frame = get_selected_frame (NULL);
1208  gdbarch = get_frame_arch (frame);
1209  numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
1210 
1211  list_cleanup = make_cleanup_ui_out_list_begin_end (uiout, "register-values");
1212 
1213  if (argc - oind == 1)
1214  {
1215  /* No args, beside the format: do all the regs. */
1216  for (regnum = 0;
1217  regnum < numregs;
1218  regnum++)
1219  {
1220  if (gdbarch_register_name (gdbarch, regnum) == NULL
1221  || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
1222  continue;
1223 
1224  output_register (frame, regnum, format, skip_unavailable);
1225  }
1226  }
1227 
1228  /* Else, list of register #s, just do listed regs. */
1229  for (i = 1 + oind; i < argc; i++)
1230  {
1231  regnum = atoi (argv[i]);
1232 
1233  if (regnum >= 0
1234  && regnum < numregs
1235  && gdbarch_register_name (gdbarch, regnum) != NULL
1236  && *gdbarch_register_name (gdbarch, regnum) != '\000')
1237  output_register (frame, regnum, format, skip_unavailable);
1238  else
1239  error (_("bad register number"));
1240  }
1241  do_cleanups (list_cleanup);
1242 }
1243 
1244 /* Output one register REGNUM's contents in the desired FORMAT. If
1245  SKIP_UNAVAILABLE is true, skip the register if it is
1246  unavailable. */
1247 
1248 static void
1249 output_register (struct frame_info *frame, int regnum, int format,
1250  int skip_unavailable)
1251 {
1252  struct gdbarch *gdbarch = get_frame_arch (frame);
1253  struct ui_out *uiout = current_uiout;
1254  struct value *val = value_of_register (regnum, frame);
1255  struct cleanup *tuple_cleanup;
1256  struct value_print_options opts;
1257  struct ui_file *stb;
1258 
1259  if (skip_unavailable && !value_entirely_available (val))
1260  return;
1261 
1262  tuple_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1263  ui_out_field_int (uiout, "number", regnum);
1264 
1265  if (format == 'N')
1266  format = 0;
1267 
1268  if (format == 'r')
1269  format = 'z';
1270 
1271  stb = mem_fileopen ();
1273 
1274  get_formatted_print_options (&opts, format);
1275  opts.deref_ref = 1;
1276  val_print (value_type (val),
1278  value_embedded_offset (val), 0,
1279  stb, 0, val, &opts, current_language);
1280  ui_out_field_stream (uiout, "value", stb);
1281 
1282  do_cleanups (tuple_cleanup);
1283 }
1284 
1285 /* Write given values into registers. The registers and values are
1286  given as pairs. The corresponding MI command is
1287  -data-write-register-values <format>
1288  [<regnum1> <value1>...<regnumN> <valueN>] */
1289 void
1290 mi_cmd_data_write_register_values (char *command, char **argv, int argc)
1291 {
1292  struct regcache *regcache;
1293  struct gdbarch *gdbarch;
1294  int numregs, i;
1295 
1296  /* Note that the test for a valid register must include checking the
1297  gdbarch_register_name because gdbarch_num_regs may be allocated
1298  for the union of the register sets within a family of related
1299  processors. In this case, some entries of gdbarch_register_name
1300  will change depending upon the particular processor being
1301  debugged. */
1302 
1303  regcache = get_current_regcache ();
1304  gdbarch = get_regcache_arch (regcache);
1305  numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
1306 
1307  if (argc == 0)
1308  error (_("-data-write-register-values: Usage: -data-write-register-"
1309  "values <format> [<regnum1> <value1>...<regnumN> <valueN>]"));
1310 
1311  if (!target_has_registers)
1312  error (_("-data-write-register-values: No registers."));
1313 
1314  if (!(argc - 1))
1315  error (_("-data-write-register-values: No regs and values specified."));
1316 
1317  if ((argc - 1) % 2)
1318  error (_("-data-write-register-values: "
1319  "Regs and vals are not in pairs."));
1320 
1321  for (i = 1; i < argc; i = i + 2)
1322  {
1323  int regnum = atoi (argv[i]);
1324 
1325  if (regnum >= 0 && regnum < numregs
1326  && gdbarch_register_name (gdbarch, regnum)
1327  && *gdbarch_register_name (gdbarch, regnum))
1328  {
1329  LONGEST value;
1330 
1331  /* Get the value as a number. */
1332  value = parse_and_eval_address (argv[i + 1]);
1333 
1334  /* Write it down. */
1335  regcache_cooked_write_signed (regcache, regnum, value);
1336  }
1337  else
1338  error (_("bad register number"));
1339  }
1340 }
1341 
1342 /* Evaluate the value of the argument. The argument is an
1343  expression. If the expression contains spaces it needs to be
1344  included in double quotes. */
1345 
1346 void
1347 mi_cmd_data_evaluate_expression (char *command, char **argv, int argc)
1348 {
1349  struct expression *expr;
1350  struct cleanup *old_chain;
1351  struct value *val;
1352  struct ui_file *stb;
1353  struct value_print_options opts;
1354  struct ui_out *uiout = current_uiout;
1355 
1356  stb = mem_fileopen ();
1357  old_chain = make_cleanup_ui_file_delete (stb);
1358 
1359  if (argc != 1)
1360  error (_("-data-evaluate-expression: "
1361  "Usage: -data-evaluate-expression expression"));
1362 
1363  expr = parse_expression (argv[0]);
1364 
1366 
1367  val = evaluate_expression (expr);
1368 
1369  /* Print the result of the expression evaluation. */
1370  get_user_print_options (&opts);
1371  opts.deref_ref = 0;
1372  common_val_print (val, stb, 0, &opts, current_language);
1373 
1374  ui_out_field_stream (uiout, "value", stb);
1375 
1376  do_cleanups (old_chain);
1377 }
1378 
1379 /* This is the -data-read-memory command.
1380 
1381  ADDR: start address of data to be dumped.
1382  WORD-FORMAT: a char indicating format for the ``word''. See
1383  the ``x'' command.
1384  WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
1385  NR_ROW: Number of rows.
1386  NR_COL: The number of colums (words per row).
1387  ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
1388  ASCHAR for unprintable characters.
1389 
1390  Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
1391  displayes them. Returns:
1392 
1393  {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
1394 
1395  Returns:
1396  The number of bytes read is SIZE*ROW*COL. */
1397 
1398 void
1399 mi_cmd_data_read_memory (char *command, char **argv, int argc)
1400 {
1401  struct gdbarch *gdbarch = get_current_arch ();
1402  struct ui_out *uiout = current_uiout;
1403  struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
1404  CORE_ADDR addr;
1405  long total_bytes, nr_cols, nr_rows;
1406  char word_format;
1407  struct type *word_type;
1408  long word_size;
1409  char word_asize;
1410  char aschar;
1411  gdb_byte *mbuf;
1412  int nr_bytes;
1413  long offset = 0;
1414  int oind = 0;
1415  char *oarg;
1416  enum opt
1417  {
1418  OFFSET_OPT
1419  };
1420  static const struct mi_opt opts[] =
1421  {
1422  {"o", OFFSET_OPT, 1},
1423  { 0, 0, 0 }
1424  };
1425 
1426  while (1)
1427  {
1428  int opt = mi_getopt ("-data-read-memory", argc, argv, opts,
1429  &oind, &oarg);
1430 
1431  if (opt < 0)
1432  break;
1433  switch ((enum opt) opt)
1434  {
1435  case OFFSET_OPT:
1436  offset = atol (oarg);
1437  break;
1438  }
1439  }
1440  argv += oind;
1441  argc -= oind;
1442 
1443  if (argc < 5 || argc > 6)
1444  error (_("-data-read-memory: Usage: "
1445  "ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR]."));
1446 
1447  /* Extract all the arguments. */
1448 
1449  /* Start address of the memory dump. */
1450  addr = parse_and_eval_address (argv[0]) + offset;
1451  /* The format character to use when displaying a memory word. See
1452  the ``x'' command. */
1453  word_format = argv[1][0];
1454  /* The size of the memory word. */
1455  word_size = atol (argv[2]);
1456  switch (word_size)
1457  {
1458  case 1:
1459  word_type = builtin_type (gdbarch)->builtin_int8;
1460  word_asize = 'b';
1461  break;
1462  case 2:
1463  word_type = builtin_type (gdbarch)->builtin_int16;
1464  word_asize = 'h';
1465  break;
1466  case 4:
1467  word_type = builtin_type (gdbarch)->builtin_int32;
1468  word_asize = 'w';
1469  break;
1470  case 8:
1471  word_type = builtin_type (gdbarch)->builtin_int64;
1472  word_asize = 'g';
1473  break;
1474  default:
1475  word_type = builtin_type (gdbarch)->builtin_int8;
1476  word_asize = 'b';
1477  }
1478  /* The number of rows. */
1479  nr_rows = atol (argv[3]);
1480  if (nr_rows <= 0)
1481  error (_("-data-read-memory: invalid number of rows."));
1482 
1483  /* Number of bytes per row. */
1484  nr_cols = atol (argv[4]);
1485  if (nr_cols <= 0)
1486  error (_("-data-read-memory: invalid number of columns."));
1487 
1488  /* The un-printable character when printing ascii. */
1489  if (argc == 6)
1490  aschar = *argv[5];
1491  else
1492  aschar = 0;
1493 
1494  /* Create a buffer and read it in. */
1495  total_bytes = word_size * nr_rows * nr_cols;
1496  mbuf = xcalloc (total_bytes, 1);
1497  make_cleanup (xfree, mbuf);
1498 
1499  /* Dispatch memory reads to the topmost target, not the flattened
1500  current_target. */
1501  nr_bytes = target_read (current_target.beneath,
1502  TARGET_OBJECT_MEMORY, NULL, mbuf,
1503  addr, total_bytes);
1504  if (nr_bytes <= 0)
1505  error (_("Unable to read memory."));
1506 
1507  /* Output the header information. */
1508  ui_out_field_core_addr (uiout, "addr", gdbarch, addr);
1509  ui_out_field_int (uiout, "nr-bytes", nr_bytes);
1510  ui_out_field_int (uiout, "total-bytes", total_bytes);
1511  ui_out_field_core_addr (uiout, "next-row",
1512  gdbarch, addr + word_size * nr_cols);
1513  ui_out_field_core_addr (uiout, "prev-row",
1514  gdbarch, addr - word_size * nr_cols);
1515  ui_out_field_core_addr (uiout, "next-page", gdbarch, addr + total_bytes);
1516  ui_out_field_core_addr (uiout, "prev-page", gdbarch, addr - total_bytes);
1517 
1518  /* Build the result as a two dimentional table. */
1519  {
1520  struct ui_file *stream;
1521  struct cleanup *cleanup_stream;
1522  int row;
1523  int row_byte;
1524 
1525  stream = mem_fileopen ();
1526  cleanup_stream = make_cleanup_ui_file_delete (stream);
1527 
1528  make_cleanup_ui_out_list_begin_end (uiout, "memory");
1529  for (row = 0, row_byte = 0;
1530  row < nr_rows;
1531  row++, row_byte += nr_cols * word_size)
1532  {
1533  int col;
1534  int col_byte;
1535  struct cleanup *cleanup_tuple;
1536  struct cleanup *cleanup_list_data;
1537  struct value_print_options opts;
1538 
1539  cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1540  ui_out_field_core_addr (uiout, "addr", gdbarch, addr + row_byte);
1541  /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr +
1542  row_byte); */
1543  cleanup_list_data = make_cleanup_ui_out_list_begin_end (uiout, "data");
1544  get_formatted_print_options (&opts, word_format);
1545  for (col = 0, col_byte = row_byte;
1546  col < nr_cols;
1547  col++, col_byte += word_size)
1548  {
1549  if (col_byte + word_size > nr_bytes)
1550  {
1551  ui_out_field_string (uiout, NULL, "N/A");
1552  }
1553  else
1554  {
1555  ui_file_rewind (stream);
1556  print_scalar_formatted (mbuf + col_byte, word_type, &opts,
1557  word_asize, stream);
1558  ui_out_field_stream (uiout, NULL, stream);
1559  }
1560  }
1561  do_cleanups (cleanup_list_data);
1562  if (aschar)
1563  {
1564  int byte;
1565 
1566  ui_file_rewind (stream);
1567  for (byte = row_byte;
1568  byte < row_byte + word_size * nr_cols; byte++)
1569  {
1570  if (byte >= nr_bytes)
1571  fputc_unfiltered ('X', stream);
1572  else if (mbuf[byte] < 32 || mbuf[byte] > 126)
1573  fputc_unfiltered (aschar, stream);
1574  else
1575  fputc_unfiltered (mbuf[byte], stream);
1576  }
1577  ui_out_field_stream (uiout, "ascii", stream);
1578  }
1579  do_cleanups (cleanup_tuple);
1580  }
1581  do_cleanups (cleanup_stream);
1582  }
1583  do_cleanups (cleanups);
1584 }
1585 
1586 void
1587 mi_cmd_data_read_memory_bytes (char *command, char **argv, int argc)
1588 {
1589  struct gdbarch *gdbarch = get_current_arch ();
1590  struct ui_out *uiout = current_uiout;
1591  struct cleanup *cleanups;
1592  CORE_ADDR addr;
1593  LONGEST length;
1594  memory_read_result_s *read_result;
1595  int ix;
1596  VEC(memory_read_result_s) *result;
1597  long offset = 0;
1598  int unit_size = gdbarch_addressable_memory_unit_size (gdbarch);
1599  int oind = 0;
1600  char *oarg;
1601  enum opt
1602  {
1603  OFFSET_OPT
1604  };
1605  static const struct mi_opt opts[] =
1606  {
1607  {"o", OFFSET_OPT, 1},
1608  { 0, 0, 0 }
1609  };
1610 
1611  while (1)
1612  {
1613  int opt = mi_getopt ("-data-read-memory-bytes", argc, argv, opts,
1614  &oind, &oarg);
1615  if (opt < 0)
1616  break;
1617  switch ((enum opt) opt)
1618  {
1619  case OFFSET_OPT:
1620  offset = atol (oarg);
1621  break;
1622  }
1623  }
1624  argv += oind;
1625  argc -= oind;
1626 
1627  if (argc != 2)
1628  error (_("Usage: [ -o OFFSET ] ADDR LENGTH."));
1629 
1630  addr = parse_and_eval_address (argv[0]) + offset;
1631  length = atol (argv[1]);
1632 
1633  result = read_memory_robust (current_target.beneath, addr, length);
1634 
1635  cleanups = make_cleanup (free_memory_read_result_vector, result);
1636 
1637  if (VEC_length (memory_read_result_s, result) == 0)
1638  error (_("Unable to read memory."));
1639 
1640  make_cleanup_ui_out_list_begin_end (uiout, "memory");
1641  for (ix = 0;
1642  VEC_iterate (memory_read_result_s, result, ix, read_result);
1643  ++ix)
1644  {
1645  struct cleanup *t = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1646  char *data, *p;
1647  int i;
1648 
1649  ui_out_field_core_addr (uiout, "begin", gdbarch, read_result->begin);
1650  ui_out_field_core_addr (uiout, "offset", gdbarch, read_result->begin
1651  - addr);
1652  ui_out_field_core_addr (uiout, "end", gdbarch, read_result->end);
1653 
1654  data = xmalloc (
1655  (read_result->end - read_result->begin) * 2 * unit_size + 1);
1656 
1657  for (i = 0, p = data;
1658  i < ((read_result->end - read_result->begin) * unit_size);
1659  ++i, p += 2)
1660  {
1661  sprintf (p, "%02x", read_result->data[i]);
1662  }
1663  ui_out_field_string (uiout, "contents", data);
1664  xfree (data);
1665  do_cleanups (t);
1666  }
1667  do_cleanups (cleanups);
1668 }
1669 
1670 /* Implementation of the -data-write_memory command.
1671 
1672  COLUMN_OFFSET: optional argument. Must be preceded by '-o'. The
1673  offset from the beginning of the memory grid row where the cell to
1674  be written is.
1675  ADDR: start address of the row in the memory grid where the memory
1676  cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
1677  the location to write to.
1678  FORMAT: a char indicating format for the ``word''. See
1679  the ``x'' command.
1680  WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
1681  VALUE: value to be written into the memory address.
1682 
1683  Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1684 
1685  Prints nothing. */
1686 
1687 void
1688 mi_cmd_data_write_memory (char *command, char **argv, int argc)
1689 {
1690  struct gdbarch *gdbarch = get_current_arch ();
1691  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1692  CORE_ADDR addr;
1693  long word_size;
1694  /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1695  enough when using a compiler other than GCC. */
1696  LONGEST value;
1697  void *buffer;
1698  struct cleanup *old_chain;
1699  long offset = 0;
1700  int oind = 0;
1701  char *oarg;
1702  enum opt
1703  {
1704  OFFSET_OPT
1705  };
1706  static const struct mi_opt opts[] =
1707  {
1708  {"o", OFFSET_OPT, 1},
1709  { 0, 0, 0 }
1710  };
1711 
1712  while (1)
1713  {
1714  int opt = mi_getopt ("-data-write-memory", argc, argv, opts,
1715  &oind, &oarg);
1716 
1717  if (opt < 0)
1718  break;
1719  switch ((enum opt) opt)
1720  {
1721  case OFFSET_OPT:
1722  offset = atol (oarg);
1723  break;
1724  }
1725  }
1726  argv += oind;
1727  argc -= oind;
1728 
1729  if (argc != 4)
1730  error (_("-data-write-memory: Usage: "
1731  "[-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE."));
1732 
1733  /* Extract all the arguments. */
1734  /* Start address of the memory dump. */
1735  addr = parse_and_eval_address (argv[0]);
1736  /* The size of the memory word. */
1737  word_size = atol (argv[2]);
1738 
1739  /* Calculate the real address of the write destination. */
1740  addr += (offset * word_size);
1741 
1742  /* Get the value as a number. */
1743  value = parse_and_eval_address (argv[3]);
1744  /* Get the value into an array. */
1745  buffer = xmalloc (word_size);
1746  old_chain = make_cleanup (xfree, buffer);
1747  store_signed_integer (buffer, word_size, byte_order, value);
1748  /* Write it down to memory. */
1749  write_memory_with_notification (addr, buffer, word_size);
1750  /* Free the buffer. */
1751  do_cleanups (old_chain);
1752 }
1753 
1754 /* Implementation of the -data-write-memory-bytes command.
1755 
1756  ADDR: start address
1757  DATA: string of bytes to write at that address
1758  COUNT: number of bytes to be filled (decimal integer). */
1759 
1760 void
1761 mi_cmd_data_write_memory_bytes (char *command, char **argv, int argc)
1762 {
1763  CORE_ADDR addr;
1764  char *cdata;
1765  gdb_byte *data;
1766  gdb_byte *databuf;
1767  size_t len_hex, len_bytes, len_units, i, steps, remaining_units;
1768  long int count_units;
1769  struct cleanup *back_to;
1770  int unit_size;
1771 
1772  if (argc != 2 && argc != 3)
1773  error (_("Usage: ADDR DATA [COUNT]."));
1774 
1775  addr = parse_and_eval_address (argv[0]);
1776  cdata = argv[1];
1777  len_hex = strlen (cdata);
1779 
1780  if (len_hex % (unit_size * 2) != 0)
1781  error (_("Hex-encoded '%s' must represent an integral number of "
1782  "addressable memory units."),
1783  cdata);
1784 
1785  len_bytes = len_hex / 2;
1786  len_units = len_bytes / unit_size;
1787 
1788  if (argc == 3)
1789  count_units = strtoul (argv[2], NULL, 10);
1790  else
1791  count_units = len_units;
1792 
1793  databuf = xmalloc (len_bytes * sizeof (gdb_byte));
1794  back_to = make_cleanup (xfree, databuf);
1795 
1796  for (i = 0; i < len_bytes; ++i)
1797  {
1798  int x;
1799  if (sscanf (cdata + i * 2, "%02x", &x) != 1)
1800  error (_("Invalid argument"));
1801  databuf[i] = (gdb_byte) x;
1802  }
1803 
1804  if (len_units < count_units)
1805  {
1806  /* Pattern is made of less units than count:
1807  repeat pattern to fill memory. */
1808  data = xmalloc (count_units * unit_size);
1809  make_cleanup (xfree, data);
1810 
1811  /* Number of times the pattern is entirely repeated. */
1812  steps = count_units / len_units;
1813  /* Number of remaining addressable memory units. */
1814  remaining_units = count_units % len_units;
1815  for (i = 0; i < steps; i++)
1816  memcpy (data + i * len_bytes, databuf, len_bytes);
1817 
1818  if (remaining_units > 0)
1819  memcpy (data + steps * len_bytes, databuf,
1820  remaining_units * unit_size);
1821  }
1822  else
1823  {
1824  /* Pattern is longer than or equal to count:
1825  just copy count addressable memory units. */
1826  data = databuf;
1827  }
1828 
1829  write_memory_with_notification (addr, data, count_units);
1830 
1831  do_cleanups (back_to);
1832 }
1833 
1834 void
1835 mi_cmd_enable_timings (char *command, char **argv, int argc)
1836 {
1837  if (argc == 0)
1838  do_timings = 1;
1839  else if (argc == 1)
1840  {
1841  if (strcmp (argv[0], "yes") == 0)
1842  do_timings = 1;
1843  else if (strcmp (argv[0], "no") == 0)
1844  do_timings = 0;
1845  else
1846  goto usage_error;
1847  }
1848  else
1849  goto usage_error;
1850 
1851  return;
1852 
1853  usage_error:
1854  error (_("-enable-timings: Usage: %s {yes|no}"), command);
1855 }
1856 
1857 void
1858 mi_cmd_list_features (char *command, char **argv, int argc)
1859 {
1860  if (argc == 0)
1861  {
1862  struct cleanup *cleanup = NULL;
1863  struct ui_out *uiout = current_uiout;
1864 
1865  cleanup = make_cleanup_ui_out_list_begin_end (uiout, "features");
1866  ui_out_field_string (uiout, NULL, "frozen-varobjs");
1867  ui_out_field_string (uiout, NULL, "pending-breakpoints");
1868  ui_out_field_string (uiout, NULL, "thread-info");
1869  ui_out_field_string (uiout, NULL, "data-read-memory-bytes");
1870  ui_out_field_string (uiout, NULL, "breakpoint-notifications");
1871  ui_out_field_string (uiout, NULL, "ada-task-info");
1872  ui_out_field_string (uiout, NULL, "language-option");
1873  ui_out_field_string (uiout, NULL, "info-gdb-mi-command");
1874  ui_out_field_string (uiout, NULL, "undefined-command-error-code");
1875  ui_out_field_string (uiout, NULL, "exec-run-start-option");
1876 
1878  ui_out_field_string (uiout, NULL, "python");
1879 
1880  do_cleanups (cleanup);
1881  return;
1882  }
1883 
1884  error (_("-list-features should be passed no arguments"));
1885 }
1886 
1887 void
1888 mi_cmd_list_target_features (char *command, char **argv, int argc)
1889 {
1890  if (argc == 0)
1891  {
1892  struct cleanup *cleanup = NULL;
1893  struct ui_out *uiout = current_uiout;
1894 
1895  cleanup = make_cleanup_ui_out_list_begin_end (uiout, "features");
1896  if (mi_async_p ())
1897  ui_out_field_string (uiout, NULL, "async");
1899  ui_out_field_string (uiout, NULL, "reverse");
1900  do_cleanups (cleanup);
1901  return;
1902  }
1903 
1904  error (_("-list-target-features should be passed no arguments"));
1905 }
1906 
1907 void
1908 mi_cmd_add_inferior (char *command, char **argv, int argc)
1909 {
1910  struct inferior *inf;
1911 
1912  if (argc != 0)
1913  error (_("-add-inferior should be passed no arguments"));
1914 
1915  inf = add_inferior_with_spaces ();
1916 
1917  ui_out_field_fmt (current_uiout, "inferior", "i%d", inf->num);
1918 }
1919 
1920 /* Callback used to find the first inferior other than the current
1921  one. */
1922 
1923 static int
1924 get_other_inferior (struct inferior *inf, void *arg)
1925 {
1926  if (inf == current_inferior ())
1927  return 0;
1928 
1929  return 1;
1930 }
1931 
1932 void
1933 mi_cmd_remove_inferior (char *command, char **argv, int argc)
1934 {
1935  int id;
1936  struct inferior *inf;
1937 
1938  if (argc != 1)
1939  error (_("-remove-inferior should be passed a single argument"));
1940 
1941  if (sscanf (argv[0], "i%d", &id) != 1)
1942  error (_("the thread group id is syntactically invalid"));
1943 
1944  inf = find_inferior_id (id);
1945  if (!inf)
1946  error (_("the specified thread group does not exist"));
1947 
1948  if (inf->pid != 0)
1949  error (_("cannot remove an active inferior"));
1950 
1951  if (inf == current_inferior ())
1952  {
1953  struct thread_info *tp = 0;
1954  struct inferior *new_inferior
1956 
1957  if (new_inferior == NULL)
1958  error (_("Cannot remove last inferior"));
1959 
1960  set_current_inferior (new_inferior);
1961  if (new_inferior->pid != 0)
1962  tp = any_thread_of_process (new_inferior->pid);
1963  switch_to_thread (tp ? tp->ptid : null_ptid);
1964  set_current_program_space (new_inferior->pspace);
1965  }
1966 
1967  delete_inferior_1 (inf, 1 /* silent */);
1968 }
1969 
1970 
1971 
1972 /* Execute a command within a safe environment.
1973  Return <0 for error; >=0 for ok.
1974 
1975  args->action will tell mi_execute_command what action
1976  to perfrom after the given command has executed (display/suppress
1977  prompt, display error). */
1978 
1979 static void
1980 captured_mi_execute_command (struct ui_out *uiout, struct mi_parse *context)
1981 {
1982  struct cleanup *cleanup;
1983 
1984  if (do_timings)
1985  current_command_ts = context->cmd_start;
1986 
1987  current_token = xstrdup (context->token);
1988  cleanup = make_cleanup (free_current_contents, &current_token);
1989 
1990  running_result_record_printed = 0;
1991  mi_proceeded = 0;
1992  switch (context->op)
1993  {
1994  case MI_COMMAND:
1995  /* A MI command was read from the input stream. */
1996  if (mi_debug_p)
1997  /* FIXME: gdb_???? */
1998  fprintf_unfiltered (raw_stdout, " token=`%s' command=`%s' args=`%s'\n",
1999  context->token, context->command, context->args);
2000 
2001  mi_cmd_execute (context);
2002 
2003  /* Print the result if there were no errors.
2004 
2005  Remember that on the way out of executing a command, you have
2006  to directly use the mi_interp's uiout, since the command
2007  could have reset the interpreter, in which case the current
2008  uiout will most likely crash in the mi_out_* routines. */
2009  if (!running_result_record_printed)
2010  {
2011  fputs_unfiltered (context->token, raw_stdout);
2012  /* There's no particularly good reason why target-connect results
2013  in not ^done. Should kill ^connected for MI3. */
2014  fputs_unfiltered (strcmp (context->command, "target-select") == 0
2015  ? "^connected" : "^done", raw_stdout);
2016  mi_out_put (uiout, raw_stdout);
2017  mi_out_rewind (uiout);
2019  fputs_unfiltered ("\n", raw_stdout);
2020  }
2021  else
2022  /* The command does not want anything to be printed. In that
2023  case, the command probably should not have written anything
2024  to uiout, but in case it has written something, discard it. */
2025  mi_out_rewind (uiout);
2026  break;
2027 
2028  case CLI_COMMAND:
2029  {
2030  char *argv[2];
2031 
2032  /* A CLI command was read from the input stream. */
2033  /* This "feature" will be removed as soon as we have a
2034  complete set of mi commands. */
2035  /* Echo the command on the console. */
2036  fprintf_unfiltered (gdb_stdlog, "%s\n", context->command);
2037  /* Call the "console" interpreter. */
2038  argv[0] = "console";
2039  argv[1] = context->command;
2040  mi_cmd_interpreter_exec ("-interpreter-exec", argv, 2);
2041 
2042  /* If we changed interpreters, DON'T print out anything. */
2047  {
2048  if (!running_result_record_printed)
2049  {
2050  fputs_unfiltered (context->token, raw_stdout);
2051  fputs_unfiltered ("^done", raw_stdout);
2052  mi_out_put (uiout, raw_stdout);
2053  mi_out_rewind (uiout);
2055  fputs_unfiltered ("\n", raw_stdout);
2056  }
2057  else
2058  mi_out_rewind (uiout);
2059  }
2060  break;
2061  }
2062  }
2063 
2064  do_cleanups (cleanup);
2065 }
2066 
2067 /* Print a gdb exception to the MI output stream. */
2068 
2069 static void
2070 mi_print_exception (const char *token, struct gdb_exception exception)
2071 {
2072  fputs_unfiltered (token, raw_stdout);
2073  fputs_unfiltered ("^error,msg=\"", raw_stdout);
2074  if (exception.message == NULL)
2075  fputs_unfiltered ("unknown error", raw_stdout);
2076  else
2077  fputstr_unfiltered (exception.message, '"', raw_stdout);
2078  fputs_unfiltered ("\"", raw_stdout);
2079 
2080  switch (exception.error)
2081  {
2083  fputs_unfiltered (",code=\"undefined-command\"", raw_stdout);
2084  break;
2085  }
2086 
2087  fputs_unfiltered ("\n", raw_stdout);
2088 }
2089 
2090 void
2091 mi_execute_command (const char *cmd, int from_tty)
2092 {
2093  char *token;
2094  struct mi_parse *command = NULL;
2095 
2096  /* This is to handle EOF (^D). We just quit gdb. */
2097  /* FIXME: we should call some API function here. */
2098  if (cmd == 0)
2099  quit_force (NULL, from_tty);
2100 
2101  target_log_command (cmd);
2102 
2103  TRY
2104  {
2105  command = mi_parse (cmd, &token);
2106  }
2107  CATCH (exception, RETURN_MASK_ALL)
2108  {
2109  mi_print_exception (token, exception);
2110  xfree (token);
2111  }
2112  END_CATCH
2113 
2114  if (command != NULL)
2115  {
2116  ptid_t previous_ptid = inferior_ptid;
2117 
2118  command->token = token;
2119 
2120  if (do_timings)
2121  {
2122  command->cmd_start = (struct mi_timestamp *)
2123  xmalloc (sizeof (struct mi_timestamp));
2124  timestamp (command->cmd_start);
2125  }
2126 
2127  TRY
2128  {
2130  }
2131  CATCH (result, RETURN_MASK_ALL)
2132  {
2133  /* The command execution failed and error() was called
2134  somewhere. */
2135  mi_print_exception (command->token, result);
2137  }
2138  END_CATCH
2139 
2140  bpstat_do_actions ();
2141 
2142  if (/* The notifications are only output when the top-level
2143  interpreter (specified on the command line) is MI. */
2145  /* Don't try report anything if there are no threads --
2146  the program is dead. */
2147  && thread_count () != 0
2148  /* -thread-select explicitly changes thread. If frontend uses that
2149  internally, we don't want to emit =thread-selected, since
2150  =thread-selected is supposed to indicate user's intentions. */
2151  && strcmp (command->command, "thread-select") != 0)
2152  {
2153  struct mi_interp *mi = top_level_interpreter_data ();
2154  int report_change = 0;
2155 
2156  if (command->thread == -1)
2157  {
2158  report_change = (!ptid_equal (previous_ptid, null_ptid)
2159  && !ptid_equal (inferior_ptid, previous_ptid)
2161  }
2162  else if (!ptid_equal (inferior_ptid, null_ptid))
2163  {
2164  struct thread_info *ti = inferior_thread ();
2165 
2166  report_change = (ti->num != command->thread);
2167  }
2168 
2169  if (report_change)
2170  {
2171  struct thread_info *ti = inferior_thread ();
2172 
2175  "thread-selected,id=\"%d\"",
2176  ti->num);
2177  gdb_flush (mi->event_channel);
2178  }
2179  }
2180 
2181  mi_parse_free (command);
2182  }
2183 }
2184 
2185 static void
2187 {
2188  struct cleanup *cleanup;
2189  enum language saved_language;
2190 
2191  cleanup = prepare_execute_command ();
2192 
2193  if (parse->all && parse->thread_group != -1)
2194  error (_("Cannot specify --thread-group together with --all"));
2195 
2196  if (parse->all && parse->thread != -1)
2197  error (_("Cannot specify --thread together with --all"));
2198 
2199  if (parse->thread_group != -1 && parse->thread != -1)
2200  error (_("Cannot specify --thread together with --thread-group"));
2201 
2202  if (parse->frame != -1 && parse->thread == -1)
2203  error (_("Cannot specify --frame without --thread"));
2204 
2205  if (parse->thread_group != -1)
2206  {
2207  struct inferior *inf = find_inferior_id (parse->thread_group);
2208  struct thread_info *tp = 0;
2209 
2210  if (!inf)
2211  error (_("Invalid thread group for the --thread-group option"));
2212 
2213  set_current_inferior (inf);
2214  /* This behaviour means that if --thread-group option identifies
2215  an inferior with multiple threads, then a random one will be
2216  picked. This is not a problem -- frontend should always
2217  provide --thread if it wishes to operate on a specific
2218  thread. */
2219  if (inf->pid != 0)
2220  tp = any_live_thread_of_process (inf->pid);
2221  switch_to_thread (tp ? tp->ptid : null_ptid);
2223  }
2224 
2225  if (parse->thread != -1)
2226  {
2227  struct thread_info *tp = find_thread_id (parse->thread);
2228 
2229  if (!tp)
2230  error (_("Invalid thread id: %d"), parse->thread);
2231 
2232  if (is_exited (tp->ptid))
2233  error (_("Thread id: %d has terminated"), parse->thread);
2234 
2235  switch_to_thread (tp->ptid);
2236  }
2237 
2238  if (parse->frame != -1)
2239  {
2240  struct frame_info *fid;
2241  int frame = parse->frame;
2242 
2243  fid = find_relative_frame (get_current_frame (), &frame);
2244  if (frame == 0)
2245  /* find_relative_frame was successful */
2246  select_frame (fid);
2247  else
2248  error (_("Invalid frame id: %d"), frame);
2249  }
2250 
2251  if (parse->language != language_unknown)
2252  {
2254  set_language (parse->language);
2255  }
2256 
2257  current_context = parse;
2258 
2259  if (parse->cmd->suppress_notification != NULL)
2260  {
2262  *parse->cmd->suppress_notification = 1;
2263  }
2264 
2265  if (parse->cmd->argv_func != NULL)
2266  {
2267  parse->cmd->argv_func (parse->command, parse->argv, parse->argc);
2268  }
2269  else if (parse->cmd->cli.cmd != 0)
2270  {
2271  /* FIXME: DELETE THIS. */
2272  /* The operation is still implemented by a cli command. */
2273  /* Must be a synchronous one. */
2274  mi_execute_cli_command (parse->cmd->cli.cmd, parse->cmd->cli.args_p,
2275  parse->args);
2276  }
2277  else
2278  {
2279  /* FIXME: DELETE THIS. */
2280  struct ui_file *stb;
2281 
2282  stb = mem_fileopen ();
2283 
2284  fputs_unfiltered ("Undefined mi command: ", stb);
2285  fputstr_unfiltered (parse->command, '"', stb);
2286  fputs_unfiltered (" (missing implementation)", stb);
2287 
2289  error_stream (stb);
2290  }
2291  do_cleanups (cleanup);
2292 }
2293 
2294 /* FIXME: This is just a hack so we can get some extra commands going.
2295  We don't want to channel things through the CLI, but call libgdb directly.
2296  Use only for synchronous commands. */
2297 
2298 void
2299 mi_execute_cli_command (const char *cmd, int args_p, const char *args)
2300 {
2301  if (cmd != 0)
2302  {
2303  struct cleanup *old_cleanups;
2304  char *run;
2305 
2306  if (args_p)
2307  run = xstrprintf ("%s %s", cmd, args);
2308  else
2309  run = xstrdup (cmd);
2310  if (mi_debug_p)
2311  /* FIXME: gdb_???? */
2312  fprintf_unfiltered (gdb_stdout, "cli=%s run=%s\n",
2313  cmd, run);
2314  old_cleanups = make_cleanup (xfree, run);
2315  execute_command (run, 0 /* from_tty */ );
2316  do_cleanups (old_cleanups);
2317  return;
2318  }
2319 }
2320 
2321 void
2322 mi_execute_async_cli_command (char *cli_command, char **argv, int argc)
2323 {
2324  struct cleanup *old_cleanups;
2325  char *run;
2326 
2327  if (mi_async_p ())
2328  run = xstrprintf ("%s %s&", cli_command, argc ? *argv : "");
2329  else
2330  run = xstrprintf ("%s %s", cli_command, argc ? *argv : "");
2331  old_cleanups = make_cleanup (xfree, run);
2332 
2333  execute_command (run, 0 /* from_tty */ );
2334 
2335  /* Do this before doing any printing. It would appear that some
2336  print code leaves garbage around in the buffer. */
2337  do_cleanups (old_cleanups);
2338 }
2339 
2340 void
2341 mi_load_progress (const char *section_name,
2342  unsigned long sent_so_far,
2343  unsigned long total_section,
2344  unsigned long total_sent,
2345  unsigned long grand_total)
2346 {
2347  struct timeval time_now, delta, update_threshold;
2348  static struct timeval last_update;
2349  static char *previous_sect_name = NULL;
2350  int new_section;
2351  struct ui_out *saved_uiout;
2352  struct ui_out *uiout;
2353 
2354  /* This function is called through deprecated_show_load_progress
2355  which means uiout may not be correct. Fix it for the duration
2356  of this function. */
2357  saved_uiout = current_uiout;
2358 
2361  current_uiout = mi_out_new (2);
2363  current_uiout = mi_out_new (1);
2365  current_uiout = mi_out_new (3);
2366  else
2367  return;
2368 
2369  uiout = current_uiout;
2370 
2371  update_threshold.tv_sec = 0;
2372  update_threshold.tv_usec = 500000;
2373  gettimeofday (&time_now, NULL);
2374 
2375  delta.tv_usec = time_now.tv_usec - last_update.tv_usec;
2376  delta.tv_sec = time_now.tv_sec - last_update.tv_sec;
2377 
2378  if (delta.tv_usec < 0)
2379  {
2380  delta.tv_sec -= 1;
2381  delta.tv_usec += 1000000L;
2382  }
2383 
2384  new_section = (previous_sect_name ?
2385  strcmp (previous_sect_name, section_name) : 1);
2386  if (new_section)
2387  {
2388  struct cleanup *cleanup_tuple;
2389 
2390  xfree (previous_sect_name);
2391  previous_sect_name = xstrdup (section_name);
2392 
2393  if (current_token)
2394  fputs_unfiltered (current_token, raw_stdout);
2395  fputs_unfiltered ("+download", raw_stdout);
2396  cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
2397  ui_out_field_string (uiout, "section", section_name);
2398  ui_out_field_int (uiout, "section-size", total_section);
2399  ui_out_field_int (uiout, "total-size", grand_total);
2400  do_cleanups (cleanup_tuple);
2401  mi_out_put (uiout, raw_stdout);
2402  fputs_unfiltered ("\n", raw_stdout);
2403  gdb_flush (raw_stdout);
2404  }
2405 
2406  if (delta.tv_sec >= update_threshold.tv_sec &&
2407  delta.tv_usec >= update_threshold.tv_usec)
2408  {
2409  struct cleanup *cleanup_tuple;
2410 
2411  last_update.tv_sec = time_now.tv_sec;
2412  last_update.tv_usec = time_now.tv_usec;
2413  if (current_token)
2414  fputs_unfiltered (current_token, raw_stdout);
2415  fputs_unfiltered ("+download", raw_stdout);
2416  cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
2417  ui_out_field_string (uiout, "section", section_name);
2418  ui_out_field_int (uiout, "section-sent", sent_so_far);
2419  ui_out_field_int (uiout, "section-size", total_section);
2420  ui_out_field_int (uiout, "total-sent", total_sent);
2421  ui_out_field_int (uiout, "total-size", grand_total);
2422  do_cleanups (cleanup_tuple);
2423  mi_out_put (uiout, raw_stdout);
2424  fputs_unfiltered ("\n", raw_stdout);
2425  gdb_flush (raw_stdout);
2426  }
2427 
2428  xfree (uiout);
2429  current_uiout = saved_uiout;
2430 }
2431 
2432 static void
2434 {
2435  gettimeofday (&tv->wallclock, NULL);
2436 #ifdef HAVE_GETRUSAGE
2437  getrusage (RUSAGE_SELF, &rusage);
2438  tv->utime.tv_sec = rusage.ru_utime.tv_sec;
2439  tv->utime.tv_usec = rusage.ru_utime.tv_usec;
2440  tv->stime.tv_sec = rusage.ru_stime.tv_sec;
2441  tv->stime.tv_usec = rusage.ru_stime.tv_usec;
2442 #else
2443  {
2444  long usec = get_run_time ();
2445 
2446  tv->utime.tv_sec = usec/1000000L;
2447  tv->utime.tv_usec = usec - 1000000L*tv->utime.tv_sec;
2448  tv->stime.tv_sec = 0;
2449  tv->stime.tv_usec = 0;
2450  }
2451 #endif
2452 }
2453 
2454 static void
2456 {
2457  struct mi_timestamp now;
2458 
2459  timestamp (&now);
2460  print_diff (start, &now);
2461 }
2462 
2463 void
2465 {
2466  /* If the command is -enable-timing then do_timings may be true
2467  whilst current_command_ts is not initialized. */
2468  if (do_timings && current_command_ts)
2469  print_diff_now (current_command_ts);
2470 }
2471 
2472 static long
2473 timeval_diff (struct timeval start, struct timeval end)
2474 {
2475  return ((end.tv_sec - start.tv_sec) * 1000000L)
2476  + (end.tv_usec - start.tv_usec);
2477 }
2478 
2479 static void
2480 print_diff (struct mi_timestamp *start, struct mi_timestamp *end)
2481 {
2483  (raw_stdout,
2484  ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
2485  timeval_diff (start->wallclock, end->wallclock) / 1000000.0,
2486  timeval_diff (start->utime, end->utime) / 1000000.0,
2487  timeval_diff (start->stime, end->stime) / 1000000.0);
2488 }
2489 
2490 void
2491 mi_cmd_trace_define_variable (char *command, char **argv, int argc)
2492 {
2493  struct expression *expr;
2494  LONGEST initval = 0;
2495  struct trace_state_variable *tsv;
2496  char *name = 0;
2497 
2498  if (argc != 1 && argc != 2)
2499  error (_("Usage: -trace-define-variable VARIABLE [VALUE]"));
2500 
2501  name = argv[0];
2502  if (*name++ != '$')
2503  error (_("Name of trace variable should start with '$'"));
2504 
2506 
2507  tsv = find_trace_state_variable (name);
2508  if (!tsv)
2509  tsv = create_trace_state_variable (name);
2510 
2511  if (argc == 2)
2512  initval = value_as_long (parse_and_eval (argv[1]));
2513 
2514  tsv->initial_value = initval;
2515 }
2516 
2517 void
2518 mi_cmd_trace_list_variables (char *command, char **argv, int argc)
2519 {
2520  if (argc != 0)
2521  error (_("-trace-list-variables: no arguments allowed"));
2522 
2523  tvariables_info_1 ();
2524 }
2525 
2526 void
2527 mi_cmd_trace_find (char *command, char **argv, int argc)
2528 {
2529  char *mode;
2530 
2531  if (argc == 0)
2532  error (_("trace selection mode is required"));
2533 
2534  mode = argv[0];
2535 
2536  if (strcmp (mode, "none") == 0)
2537  {
2538  tfind_1 (tfind_number, -1, 0, 0, 0);
2539  return;
2540  }
2541 
2543 
2544  if (strcmp (mode, "frame-number") == 0)
2545  {
2546  if (argc != 2)
2547  error (_("frame number is required"));
2548  tfind_1 (tfind_number, atoi (argv[1]), 0, 0, 0);
2549  }
2550  else if (strcmp (mode, "tracepoint-number") == 0)
2551  {
2552  if (argc != 2)
2553  error (_("tracepoint number is required"));
2554  tfind_1 (tfind_tp, atoi (argv[1]), 0, 0, 0);
2555  }
2556  else if (strcmp (mode, "pc") == 0)
2557  {
2558  if (argc != 2)
2559  error (_("PC is required"));
2560  tfind_1 (tfind_pc, 0, parse_and_eval_address (argv[1]), 0, 0);
2561  }
2562  else if (strcmp (mode, "pc-inside-range") == 0)
2563  {
2564  if (argc != 3)
2565  error (_("Start and end PC are required"));
2567  parse_and_eval_address (argv[2]), 0);
2568  }
2569  else if (strcmp (mode, "pc-outside-range") == 0)
2570  {
2571  if (argc != 3)
2572  error (_("Start and end PC are required"));
2574  parse_and_eval_address (argv[2]), 0);
2575  }
2576  else if (strcmp (mode, "line") == 0)
2577  {
2578  struct symtabs_and_lines sals;
2579  struct symtab_and_line sal;
2580  static CORE_ADDR start_pc, end_pc;
2581  struct cleanup *back_to;
2582 
2583  if (argc != 2)
2584  error (_("Line is required"));
2585 
2586  sals = decode_line_with_current_source (argv[1],
2588  back_to = make_cleanup (xfree, sals.sals);
2589 
2590  sal = sals.sals[0];
2591 
2592  if (sal.symtab == 0)
2593  error (_("Could not find the specified line"));
2594 
2595  if (sal.line > 0 && find_line_pc_range (sal, &start_pc, &end_pc))
2596  tfind_1 (tfind_range, 0, start_pc, end_pc - 1, 0);
2597  else
2598  error (_("Could not find the specified line"));
2599 
2600  do_cleanups (back_to);
2601  }
2602  else
2603  error (_("Invalid mode '%s'"), mode);
2604 
2605  if (has_stack_frames () || get_traceframe_number () >= 0)
2607 }
2608 
2609 void
2610 mi_cmd_trace_save (char *command, char **argv, int argc)
2611 {
2612  int target_saves = 0;
2613  int generate_ctf = 0;
2614  char *filename;
2615  int oind = 0;
2616  char *oarg;
2617 
2618  enum opt
2619  {
2620  TARGET_SAVE_OPT, CTF_OPT
2621  };
2622  static const struct mi_opt opts[] =
2623  {
2624  {"r", TARGET_SAVE_OPT, 0},
2625  {"ctf", CTF_OPT, 0},
2626  { 0, 0, 0 }
2627  };
2628 
2629  while (1)
2630  {
2631  int opt = mi_getopt ("-trace-save", argc, argv, opts,
2632  &oind, &oarg);
2633 
2634  if (opt < 0)
2635  break;
2636  switch ((enum opt) opt)
2637  {
2638  case TARGET_SAVE_OPT:
2639  target_saves = 1;
2640  break;
2641  case CTF_OPT:
2642  generate_ctf = 1;
2643  break;
2644  }
2645  }
2646  filename = argv[oind];
2647 
2648  if (generate_ctf)
2649  trace_save_ctf (filename, target_saves);
2650  else
2651  trace_save_tfile (filename, target_saves);
2652 }
2653 
2654 void
2655 mi_cmd_trace_start (char *command, char **argv, int argc)
2656 {
2657  start_tracing (NULL);
2658 }
2659 
2660 void
2661 mi_cmd_trace_status (char *command, char **argv, int argc)
2662 {
2663  trace_status_mi (0);
2664 }
2665 
2666 void
2667 mi_cmd_trace_stop (char *command, char **argv, int argc)
2668 {
2669  stop_tracing (NULL);
2670  trace_status_mi (1);
2671 }
2672 
2673 /* Implement the "-ada-task-info" command. */
2674 
2675 void
2676 mi_cmd_ada_task_info (char *command, char **argv, int argc)
2677 {
2678  if (argc != 0 && argc != 1)
2679  error (_("Invalid MI command"));
2680 
2682 }
2683 
2684 /* Print EXPRESSION according to VALUES. */
2685 
2686 static void
2688 {
2689  struct expression *expr;
2690  struct cleanup *old_chain;
2691  struct value *val;
2692  struct ui_file *stb;
2693  struct value_print_options opts;
2694  struct type *type;
2695  struct ui_out *uiout = current_uiout;
2696 
2697  stb = mem_fileopen ();
2698  old_chain = make_cleanup_ui_file_delete (stb);
2699 
2700  expr = parse_expression (expression);
2701 
2703 
2704  if (values == PRINT_SIMPLE_VALUES)
2705  val = evaluate_type (expr);
2706  else
2707  val = evaluate_expression (expr);
2708 
2709  if (values != PRINT_NO_VALUES)
2711  ui_out_field_string (uiout, "name", expression);
2712 
2713  switch (values)
2714  {
2715  case PRINT_SIMPLE_VALUES:
2716  type = check_typedef (value_type (val));
2717  type_print (value_type (val), "", stb, -1);
2718  ui_out_field_stream (uiout, "type", stb);
2719  if (TYPE_CODE (type) != TYPE_CODE_ARRAY
2720  && TYPE_CODE (type) != TYPE_CODE_STRUCT
2721  && TYPE_CODE (type) != TYPE_CODE_UNION)
2722  {
2723  struct value_print_options opts;
2724 
2726  opts.deref_ref = 1;
2727  common_val_print (val, stb, 0, &opts, current_language);
2728  ui_out_field_stream (uiout, "value", stb);
2729  }
2730  break;
2731  case PRINT_ALL_VALUES:
2732  {
2733  struct value_print_options opts;
2734 
2736  opts.deref_ref = 1;
2737  common_val_print (val, stb, 0, &opts, current_language);
2738  ui_out_field_stream (uiout, "value", stb);
2739  }
2740  break;
2741  }
2742 
2743  do_cleanups (old_chain);
2744 }
2745 
2746 /* Implement the "-trace-frame-collected" command. */
2747 
2748 void
2749 mi_cmd_trace_frame_collected (char *command, char **argv, int argc)
2750 {
2751  struct cleanup *old_chain;
2752  struct bp_location *tloc;
2753  int stepping_frame;
2754  struct collection_list *clist;
2755  struct collection_list tracepoint_list, stepping_list;
2756  struct traceframe_info *tinfo;
2757  int oind = 0;
2758  int var_print_values = PRINT_ALL_VALUES;
2759  int comp_print_values = PRINT_ALL_VALUES;
2760  int registers_format = 'x';
2761  int memory_contents = 0;
2762  struct ui_out *uiout = current_uiout;
2763  enum opt
2764  {
2765  VAR_PRINT_VALUES,
2766  COMP_PRINT_VALUES,
2767  REGISTERS_FORMAT,
2768  MEMORY_CONTENTS,
2769  };
2770  static const struct mi_opt opts[] =
2771  {
2772  {"-var-print-values", VAR_PRINT_VALUES, 1},
2773  {"-comp-print-values", COMP_PRINT_VALUES, 1},
2774  {"-registers-format", REGISTERS_FORMAT, 1},
2775  {"-memory-contents", MEMORY_CONTENTS, 0},
2776  { 0, 0, 0 }
2777  };
2778 
2779  while (1)
2780  {
2781  char *oarg;
2782  int opt = mi_getopt ("-trace-frame-collected", argc, argv, opts,
2783  &oind, &oarg);
2784  if (opt < 0)
2785  break;
2786  switch ((enum opt) opt)
2787  {
2788  case VAR_PRINT_VALUES:
2789  var_print_values = mi_parse_print_values (oarg);
2790  break;
2791  case COMP_PRINT_VALUES:
2792  comp_print_values = mi_parse_print_values (oarg);
2793  break;
2794  case REGISTERS_FORMAT:
2795  registers_format = oarg[0];
2796  case MEMORY_CONTENTS:
2797  memory_contents = 1;
2798  break;
2799  }
2800  }
2801 
2802  if (oind != argc)
2803  error (_("Usage: -trace-frame-collected "
2804  "[--var-print-values PRINT_VALUES] "
2805  "[--comp-print-values PRINT_VALUES] "
2806  "[--registers-format FORMAT]"
2807  "[--memory-contents]"));
2808 
2809  /* This throws an error is not inspecting a trace frame. */
2810  tloc = get_traceframe_location (&stepping_frame);
2811 
2812  /* This command only makes sense for the current frame, not the
2813  selected frame. */
2814  old_chain = make_cleanup_restore_current_thread ();
2816 
2817  encode_actions_and_make_cleanup (tloc, &tracepoint_list,
2818  &stepping_list);
2819 
2820  if (stepping_frame)
2821  clist = &stepping_list;
2822  else
2823  clist = &tracepoint_list;
2824 
2825  tinfo = get_traceframe_info ();
2826 
2827  /* Explicitly wholly collected variables. */
2828  {
2829  struct cleanup *list_cleanup;
2830  char *p;
2831  int i;
2832 
2833  list_cleanup = make_cleanup_ui_out_list_begin_end (uiout,
2834  "explicit-variables");
2835  for (i = 0; VEC_iterate (char_ptr, clist->wholly_collected, i, p); i++)
2836  print_variable_or_computed (p, var_print_values);
2837  do_cleanups (list_cleanup);
2838  }
2839 
2840  /* Computed expressions. */
2841  {
2842  struct cleanup *list_cleanup;
2843  char *p;
2844  int i;
2845 
2846  list_cleanup
2848  "computed-expressions");
2849  for (i = 0; VEC_iterate (char_ptr, clist->computed, i, p); i++)
2850  print_variable_or_computed (p, comp_print_values);
2851  do_cleanups (list_cleanup);
2852  }
2853 
2854  /* Registers. Given pseudo-registers, and that some architectures
2855  (like MIPS) actually hide the raw registers, we don't go through
2856  the trace frame info, but instead consult the register cache for
2857  register availability. */
2858  {
2859  struct cleanup *list_cleanup;
2860  struct frame_info *frame;
2861  struct gdbarch *gdbarch;
2862  int regnum;
2863  int numregs;
2864 
2865  list_cleanup = make_cleanup_ui_out_list_begin_end (uiout, "registers");
2866 
2867  frame = get_selected_frame (NULL);
2868  gdbarch = get_frame_arch (frame);
2869  numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
2870 
2871  for (regnum = 0; regnum < numregs; regnum++)
2872  {
2873  if (gdbarch_register_name (gdbarch, regnum) == NULL
2874  || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
2875  continue;
2876 
2877  output_register (frame, regnum, registers_format, 1);
2878  }
2879 
2880  do_cleanups (list_cleanup);
2881  }
2882 
2883  /* Trace state variables. */
2884  {
2885  struct cleanup *list_cleanup;
2886  int tvar;
2887  char *tsvname;
2888  int i;
2889 
2890  list_cleanup = make_cleanup_ui_out_list_begin_end (uiout, "tvars");
2891 
2892  tsvname = NULL;
2893  make_cleanup (free_current_contents, &tsvname);
2894 
2895  for (i = 0; VEC_iterate (int, tinfo->tvars, i, tvar); i++)
2896  {
2897  struct cleanup *cleanup_child;
2898  struct trace_state_variable *tsv;
2899 
2901 
2902  cleanup_child = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
2903 
2904  if (tsv != NULL)
2905  {
2906  tsvname = xrealloc (tsvname, strlen (tsv->name) + 2);
2907  tsvname[0] = '$';
2908  strcpy (tsvname + 1, tsv->name);
2909  ui_out_field_string (uiout, "name", tsvname);
2910 
2912  &tsv->value);
2913  ui_out_field_int (uiout, "current", tsv->value);
2914  }
2915  else
2916  {
2917  ui_out_field_skip (uiout, "name");
2918  ui_out_field_skip (uiout, "current");
2919  }
2920 
2921  do_cleanups (cleanup_child);
2922  }
2923 
2924  do_cleanups (list_cleanup);
2925  }
2926 
2927  /* Memory. */
2928  {
2929  struct cleanup *list_cleanup;
2930  VEC(mem_range_s) *available_memory = NULL;
2931  struct mem_range *r;
2932  int i;
2933 
2934  traceframe_available_memory (&available_memory, 0, ULONGEST_MAX);
2935  make_cleanup (VEC_cleanup(mem_range_s), &available_memory);
2936 
2937  list_cleanup = make_cleanup_ui_out_list_begin_end (uiout, "memory");
2938 
2939  for (i = 0; VEC_iterate (mem_range_s, available_memory, i, r); i++)
2940  {
2941  struct cleanup *cleanup_child;
2942  gdb_byte *data;
2943  struct gdbarch *gdbarch = target_gdbarch ();
2944 
2945  cleanup_child = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
2946 
2947  ui_out_field_core_addr (uiout, "address", gdbarch, r->start);
2948  ui_out_field_int (uiout, "length", r->length);
2949 
2950  data = xmalloc (r->length);
2951  make_cleanup (xfree, data);
2952 
2953  if (memory_contents)
2954  {
2955  if (target_read_memory (r->start, data, r->length) == 0)
2956  {
2957  int m;
2958  char *data_str, *p;
2959 
2960  data_str = xmalloc (r->length * 2 + 1);
2961  make_cleanup (xfree, data_str);
2962 
2963  for (m = 0, p = data_str; m < r->length; ++m, p += 2)
2964  sprintf (p, "%02x", data[m]);
2965  ui_out_field_string (uiout, "contents", data_str);
2966  }
2967  else
2968  ui_out_field_skip (uiout, "contents");
2969  }
2970  do_cleanups (cleanup_child);
2971  }
2972 
2973  do_cleanups (list_cleanup);
2974  }
2975 
2976  do_cleanups (old_chain);
2977 }
2978 
2979 void
2981 {
2982  struct cmd_list_element *c;
2983 
2984  add_setshow_boolean_cmd ("mi-async", class_run,
2985  &mi_async_1, _("\
2986 Set whether MI asynchronous mode is enabled."), _("\
2987 Show whether MI asynchronous mode is enabled."), _("\
2988 Tells GDB whether MI should be in asynchronous mode."),
2991  &setlist,
2992  &showlist);
2993 
2994  /* Alias old "target-async" to "mi-async". */
2995  c = add_alias_cmd ("target-async", "mi-async", class_run, 0, &setlist);
2996  deprecate_cmd (c, "set mi-async");
2997  c = add_alias_cmd ("target-async", "mi-async", class_run, 0, &showlist);
2998  deprecate_cmd (c, "show mi-async");
2999 }
struct gdbarch * target_gdbarch(void)
Definition: gdbarch.c:5143
#define target_can_async_p()
Definition: target.h:1748
struct rusage rusage
Definition: mi-main.c:65
void mi_cmd_exec_interrupt(char *command, char **argv, int argc)
Definition: mi-main.c:376
void mi_cmd_trace_save(char *command, char **argv, int argc)
Definition: mi-main.c:2610
void mi_cmd_exec_return(char *command, char **argv, int argc)
Definition: mi-main.c:219
int have_live_inferiors(void)
Definition: inferior.c:472
void target_terminal_ours(void)
Definition: target.c:491
#define target_has_registers
Definition: target.h:1710
struct traceframe_info * get_traceframe_info(void)
Definition: tracepoint.c:4276
struct mi_timestamp * cmd_start
Definition: mi-parse.h:45
static int do_timings
Definition: mi-main.c:81
#define target_can_execute_reverse
Definition: target.h:1960
gdb_byte * data
Definition: target.h:301
struct thread_info * find_thread_id(int num)
Definition: thread.c:380
void mi_cmd_data_list_changed_registers(char *command, char **argv, int argc)
Definition: mi-main.c:1046
static void print_diff(struct mi_timestamp *start, struct mi_timestamp *end)
Definition: mi-main.c:2480
static void list_available_thread_groups(VEC(int)*ids, int recurse)
Definition: mi-main.c:767
struct frame_info * get_selected_frame(const char *message)
Definition: frame.c:1535
void target_stop(ptid_t ptid)
Definition: target.c:3289
void mi_cmd_list_target_features(char *command, char **argv, int argc)
Definition: mi-main.c:1888
void ui_out_field_stream(struct ui_out *uiout, const char *fldname, struct ui_file *stream)
Definition: ui-out.c:509
void ui_out_field_int(struct ui_out *uiout, const char *fldname, int value)
Definition: ui-out.c:467
struct frame_info * get_current_frame(void)
Definition: frame.c:1461
int ptid_equal(ptid_t ptid1, ptid_t ptid2)
Definition: ptid.c:76
bfd_vma CORE_ADDR
Definition: common-types.h:41
static void proceed_thread(struct thread_info *thread, int pid)
Definition: mi-main.c:245
#define target_shortname
Definition: target.h:1242
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
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
static void exec_direction_forward(void *notused)
Definition: mi-main.c:322
void interrupt_target_1(int all_threads)
Definition: infcmd.c:2829
void mi_cmd_exec_run(char *command, char **argv, int argc)
Definition: mi-main.c:444
void store_signed_integer(gdb_byte *, int, enum bfd_endian, LONGEST)
Definition: findvar.c:184
static int parse(struct parser_state *ps)
Definition: ada-lang.c:13721
struct gdbarch * get_regcache_arch(const struct regcache *regcache)
Definition: regcache.c:297
LONGEST value_as_long(struct value *val)
Definition: value.c:2654
int mi_proceeded
Definition: mi-main.c:93
static struct mi_timestamp * current_command_ts
Definition: mi-main.c:79
struct cmd_list_element * deprecate_cmd(struct cmd_list_element *cmd, const char *replacement)
Definition: cli-decode.c:272
const struct mi_cmd * cmd
Definition: mi-parse.h:44
unsigned available
Definition: go32-nat.c:1070
tuple inf
Definition: arm-linux.py:13
char * current_token
Definition: mi-main.c:83
enum language set_language(enum language lang)
Definition: language.c:346
struct osdata * get_osdata(const char *type)
Definition: osdata.c:244
void regcache_cooked_write_signed(struct regcache *regcache, int regnum, LONGEST val)
Definition: regcache.c:857
char ** argv
Definition: mi-parse.h:47
void get_formatted_print_options(struct value_print_options *opts, char format)
Definition: valprint.c:146
struct mi_cli cli
Definition: mi-cmds.h:142
struct ui_file * gdb_stdout
Definition: main.c:71
const struct builtin_type * builtin_type(struct gdbarch *gdbarch)
Definition: gdbtypes.c:4766
void common_val_print(struct value *val, struct ui_file *stream, int recurse, const struct value_print_options *options, const struct language_defn *language)
Definition: valprint.c:846
int pid
Definition: inferior.h:299
void select_frame(struct frame_info *fi)
Definition: frame.c:1574
enum errors error
struct thread_info * inferior_thread(void)
Definition: thread.c:85
int num
Definition: inferior.h:295
struct ui_out * interp_ui_out(struct interp *interp)
Definition: interps.c:229
void mi_cmd_data_list_register_values(char *command, char **argv, int argc)
Definition: mi-main.c:1157
int ui_out_is_mi_like_p(struct ui_out *uiout)
Definition: ui-out.c:655
int traceframe_available_memory(VEC(mem_range_s)**result, CORE_ADDR memaddr, ULONGEST len)
Definition: tracepoint.c:4291
void switch_to_thread(ptid_t ptid)
Definition: thread.c:1185
#define target_log_command(p)
Definition: target.h:2173
static int proceed_thread_callback(struct thread_info *thread, void *arg)
Definition: mi-main.c:259
struct regcache * frame_save_as_regcache(struct frame_info *this_frame)
Definition: frame.c:940
void mi_cmd_trace_define_variable(char *command, char **argv, int argc)
Definition: mi-main.c:2491
void quit_force(char *args, int from_tty)
Definition: top.c:1497
void trace_status_mi(int on_stop)
Definition: tracepoint.c:2147
static int interrupt_thread_callback(struct thread_info *thread, void *arg)
Definition: mi-main.c:355
void type_print(struct type *type, const char *varstring, struct ui_file *stream, int show)
Definition: typeprint.c:360
static long timeval_diff(struct timeval start, struct timeval end)
Definition: mi-main.c:2473
static int find_thread_of_process(struct thread_info *ti, void *p)
Definition: mi-main.c:500
#define INTERP_MI1
Definition: interps.h:109
struct bp_location * get_traceframe_location(int *stepping_frame_p)
Definition: tracepoint.c:2972
Definition: c-exp.c:4859
#define VEC_safe_push(T, V, O)
Definition: vec.h:260
void get_no_prettyformat_print_options(struct value_print_options *opts)
Definition: valprint.c:137
static void mi_cmd_execute(struct mi_parse *parse)
Definition: mi-main.c:2186
int sched_multi
Definition: infrun.c:1996
struct inferior * iterate_over_inferiors(int(*callback)(struct inferior *, void *), void *data)
Definition: inferior.c:398
#define VEC(T)
Definition: vec.h:398
int gdbarch_num_regs(struct gdbarch *gdbarch)
Definition: gdbarch.c:1898
LONGEST exit_code
Definition: inferior.h:375
static int get_other_inferior(struct inferior *inf, void *arg)
Definition: mi-main.c:1924
#define _(String)
Definition: gdb_locale.h:40
const gdb_byte * value_contents_for_printing(struct value *value)
Definition: value.c:1173
void execute_command(char *, int)
Definition: top.c:388
char * char_ptr
Definition: gdb_vecs.h:25
#define INTERP_MI
Definition: interps.h:112
#define ULONGEST_MAX
Definition: defs.h:525
#define END_CATCH
void ui_out_field_fmt(struct ui_out *uiout, const char *fldname, const char *format,...)
Definition: ui-out.c:556
Definition: ui-out.c:99
void mi_cmd_exec_jump(char *args, char **argv, int argc)
Definition: mi-main.c:238
struct regcache * get_current_regcache(void)
Definition: regcache.c:541
tuple m
Definition: arm-linux.py:44
struct type * builtin_int32
Definition: gdbtypes.h:1518
void mi_out_put(struct ui_out *uiout, struct ui_file *stream)
Definition: mi-out.c:380
Definition: ptid.h:35
void mi_cmd_trace_stop(char *command, char **argv, int argc)
Definition: mi-main.c:2667
void set_current_program_space(struct program_space *pspace)
Definition: progspace.c:199
static struct mi_parse * current_context
Definition: mi-main.c:87
struct trace_status * current_trace_status(void)
Definition: tracepoint.c:205
void mi_cmd_trace_frame_collected(char *command, char **argv, int argc)
Definition: mi-main.c:2749
enum mi_command_type op
Definition: mi-parse.h:41
int gdbarch_addressable_memory_unit_size(struct gdbarch *gdbarch)
Definition: gdbarch.c:4740
int gdbarch_num_pseudo_regs(struct gdbarch *gdbarch)
Definition: gdbarch.c:1916
void null_cleanup(void *arg)
Definition: cleanups.c:295
#define target_get_trace_state_variable_value(tsv, val)
Definition: target.h:2112
struct value * evaluate_expression(struct expression *exp)
Definition: eval.c:159
#define TRY
int thread_count(void)
Definition: thread.c:435
struct thread_info * iterate_over_threads(thread_callback_func, void *)
Definition: thread.c:419
static int collect_cores(struct thread_info *ti, void *xdata)
Definition: mi-main.c:611
struct cmd_list_element * setlist
Definition: cli-cmds.c:135
const char *const name
Definition: aarch64-tdep.c:68
void trace_save_ctf(const char *dirname, int target_does_save)
Definition: tracefile.c:369
void fputstr_unfiltered(const char *str, int quoter, struct ui_file *stream)
Definition: utils.c:1566
#define VEC_iterate(T, V, I, P)
Definition: vec.h:165
void mi_print_timing_maybe(void)
Definition: mi-main.c:2464
int is_stopped(ptid_t ptid)
Definition: thread.c:822
struct type * check_typedef(struct type *type)
Definition: gdbtypes.c:2217
int mi_getopt(const char *prefix, int argc, char **argv, const struct mi_opt *opts, int *oind, char **oarg)
Definition: mi-getopt.c:83
#define CATCH(EXCEPTION, MASK)
struct cleanup * make_cleanup_restore_integer(int *variable)
Definition: utils.c:292
void ui_out_field_skip(struct ui_out *uiout, const char *fldname)
Definition: ui-out.c:528
struct ui_file * raw_stdout
Definition: mi-main.c:75
int fputc_unfiltered(int c, struct ui_file *stream)
Definition: utils.c:2169
char * command
Definition: mi-parse.h:42
struct target_ops current_target
struct mi_parse * mi_parse(const char *cmd, char **token)
Definition: mi-parse.c:236
void print_ada_task_info(struct ui_out *uiout, char *taskno_str, struct inferior *inf)
Definition: ada-tasks.c:1001
struct cleanup * make_cleanup_ui_out_list_begin_end(struct ui_out *uiout, const char *id)
Definition: ui-out.c:459
void mi_cmd_gdb_exit(char *command, char **argv, int argc)
Definition: mi-main.c:156
struct cleanup * make_cleanup_ui_out_tuple_begin_end(struct ui_out *uiout, const char *id)
Definition: ui-out.c:451
struct program_space * pspace
Definition: inferior.h:317
void fprintf_filtered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2351
struct frame_info * find_relative_frame(struct frame_info *, int *)
Definition: stack.c:2248
static void exec_reverse_continue(char **argv, int argc)
Definition: mi-main.c:328
register_status
Definition: regcache.h:50
int * suppress_notification
Definition: mi-cmds.h:150
static void output_register(struct frame_info *, int regnum, int format, int skip_unavailable)
Definition: mi-main.c:1249
mi_cmd_argv_ftype mi_cmd_interpreter_exec
int argc
Definition: mi-parse.h:48
struct thread_info * any_live_thread_of_process(int pid)
Definition: thread.c:528
void fprintf_unfiltered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2361
struct cleanup * make_cleanup_osdata_free(struct osdata *data)
Definition: osdata.c:238
struct cmd_list_element * showlist
Definition: cli-cmds.c:143
void mi_cmd_thread_list_ids(char *command, char **argv, int argc)
Definition: mi-main.c:577
struct type * builtin_int16
Definition: gdbtypes.h:1516
struct timeval stime
Definition: mi-parse.h:31
void free_current_contents(void *ptr)
Definition: utils.c:476
void mi_cmd_exec_finish(char *command, char **argv, int argc)
Definition: mi-main.c:209
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition: gdbarch.c:1420
#define VEC_length(T, V)
Definition: vec.h:124
int get_traceframe_number(void)
Definition: tracepoint.c:3180
void mi_cmd_data_write_memory_bytes(char *command, char **argv, int argc)
Definition: mi-main.c:1761
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
Definition: cleanups.c:117
gdb_rc
Definition: gdb.h:27
Definition: gdbtypes.h:749
static void print_variable_or_computed(char *expression, enum print_values values)
Definition: mi-main.c:2687
static int register_changed_p(int regnum, struct regcache *, struct regcache *)
Definition: mi-main.c:1120
char ** argv
Definition: inferior.h:329
void mi_cmd_exec_next(char *command, char **argv, int argc)
Definition: mi-main.c:169
Definition: gnu-nat.c:163
exec_direction_kind
Definition: infrun.h:65
struct gdbarch * get_current_arch(void)
Definition: arch-utils.c:781
static const char * type
Definition: language.c:103
void error_stream(struct ui_file *stream)
Definition: utils.c:528
static void free_splay_tree(void *xt)
Definition: mi-main.c:760
const char * gdbarch_register_name(struct gdbarch *gdbarch, int regnr)
Definition: gdbarch.c:2117
static void do_nothing(splay_tree_key k)
Definition: mi-main.c:737
void stop_tracing(char *note)
Definition: tracepoint.c:1936
struct cleanup * encode_actions_and_make_cleanup(struct bp_location *tloc, struct collection_list *tracepoint_list, struct collection_list *stepping_list)
Definition: tracepoint.c:1650
void mi_cmd_ada_task_info(char *command, char **argv, int argc)
Definition: mi-main.c:2676
void mi_out_rewind(struct ui_out *uiout)
Definition: mi-out.c:370
void mi_cmd_list_thread_groups(char *command, char **argv, int argc)
Definition: mi-main.c:891
int token
Definition: m2-exp.c:2578
struct cmd_list_element * add_alias_cmd(const char *name, const char *oldname, enum command_class theclass, int abbrev_flag, struct cmd_list_element **list)
Definition: cli-decode.c:286
int mi_debug_p
Definition: mi-main.c:73
int running_result_record_printed
Definition: mi-main.c:89
static void timestamp(struct mi_timestamp *tv)
Definition: mi-main.c:2433
char * xstrprintf(const char *format,...)
Definition: common-utils.c:107
void validate_trace_state_variable_name(const char *name)
Definition: tracepoint.c:365
void mi_cmd_data_write_memory(char *command, char **argv, int argc)
Definition: mi-main.c:1688
int regnum
Definition: aarch64-tdep.c:69
Definition: osdata.h:38
void check_trace_running(struct trace_status *status)
Definition: tracepoint.c:2449
struct timeval utime
Definition: mi-parse.h:30
static procfs_run run
Definition: nto-procfs.c:52
ULONGEST end
Definition: target.h:299
void * xmalloc(YYSIZE_T)
struct symtab * symtab
Definition: symtab.h:1369
int compare_positive_ints(const void *ap, const void *bp)
Definition: utils.c:3046
struct ui_file * gdb_stdlog
Definition: main.c:73
struct ui_out * mi_out_new(int mi_version)
Definition: mi-out.c:401
struct ui_file * mem_fileopen(void)
Definition: ui-file.c:427
struct expression * parse_expression(const char *)
Definition: parse.c:1261
void mi_cmd_enable_timings(char *command, char **argv, int argc)
Definition: mi-main.c:1835
ULONGEST begin
Definition: target.h:297
void mi_cmd_data_write_register_values(char *command, char **argv, int argc)
Definition: mi-main.c:1290
void start_tracing(char *notes)
Definition: tracepoint.c:1773
void mi_cmd_trace_status(char *command, char **argv, int argc)
Definition: mi-main.c:2661
void print_thread_info(struct ui_out *uiout, char *threads, int pid)
Definition: thread.c:978
const struct extension_language_defn * get_ext_lang_defn(enum extension_language lang)
Definition: extension.c:115
void continue_1(int all_threads)
Definition: infcmd.c:719
#define VEC_empty(T, V)
Definition: vec.h:132
Definition: value.c:172
void mi_cmd_trace_list_variables(char *command, char **argv, int argc)
Definition: mi-main.c:2518
void print_scalar_formatted(const void *, struct type *, const struct value_print_options *, int, struct ui_file *)
Definition: printcmd.c:349
int ptid_get_pid(ptid_t ptid)
Definition: ptid.c:52
static void exec_continue(char **argv, int argc)
Definition: mi-main.c:268
PTR xrealloc(PTR ptr, size_t size)
Definition: common-utils.c:51
char * token
Definition: mi-parse.h:43
void print_stack_frame(struct frame_info *, int print_level, enum print_what print_what, int set_current_sal)
Definition: stack.c:151
int thread_group
Definition: mi-parse.h:50
struct timeval wallclock
Definition: mi-parse.h:29
const char const char int
Definition: command.h:229
bfd_byte gdb_byte
Definition: common-types.h:38
int find_line_pc_range(struct symtab_and_line sal, CORE_ADDR *startptr, CORE_ADDR *endptr)
Definition: symtab.c:3511
void mi_cmd_add_inferior(char *command, char **argv, int argc)
Definition: mi-main.c:1908
void mi_cmd_trace_find(char *command, char **argv, int argc)
Definition: mi-main.c:2527
int value_entirely_available(struct value *value)
Definition: value.c:368
int non_stop
Definition: infrun.c:180
static void set_mi_async_command(char *args, int from_tty, struct cmd_list_element *c)
Definition: mi-main.c:115
void * top_level_interpreter_data(void)
Definition: interps.c:482
const struct language_defn * current_language
Definition: language.c:85
ptid_t null_ptid
Definition: ptid.c:25
void mi_parse_free(struct mi_parse *parse)
Definition: mi-parse.c:212
void free_memory_read_result_vector(void *x)
Definition: target.c:1769
void tfind_1(enum trace_find_type type, int num, CORE_ADDR addr1, CORE_ADDR addr2, int from_tty)
Definition: tracepoint.c:2313
struct cleanup * prepare_execute_command(void)
Definition: top.c:308
void proceed(CORE_ADDR addr, enum gdb_signal siggnal)
Definition: infrun.c:2592
struct cleanup * make_cleanup_ui_file_delete(struct ui_file *arg)
Definition: utils.c:237
int args_p
Definition: mi-cmds.h:133
void update_thread_list(void)
Definition: thread.c:1735
ptid_t ptid
Definition: gdbthread.h:169
CORE_ADDR parse_and_eval_address(const char *exp)
Definition: eval.c:96
#define TYPE_CODE(thistype)
Definition: gdbtypes.h:1240
struct value * value_of_register(int regnum, struct frame_info *frame)
Definition: findvar.c:260
void clear_proceed_status(int step)
Definition: infrun.c:2463
#define INTERP_MI3
Definition: interps.h:111
int target_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, ssize_t len)
Definition: target.c:1393
ptid_t inferior_ptid
Definition: infcmd.c:124
void mi_cmd_data_list_register_names(char *command, char **argv, int argc)
Definition: mi-main.c:993
struct cleanup * make_cleanup_restore_current_thread(void)
Definition: thread.c:1354
char * pspace_exec_filename
Definition: progspace.h:155
int offset
Definition: agent.c:65
void get_user_print_options(struct value_print_options *opts)
Definition: valprint.c:129
void tvariables_info_1(void)
Definition: tracepoint.c:482
static void mi_execute_async_cli_command(char *cli_command, char **argv, int argc)
Definition: mi-main.c:2322
Definition: buffer.h:23
#define VEC_free(T, V)
Definition: vec.h:180
#define qsort
Definition: ada-exp.c:2747
int frame
Definition: mi-parse.h:52
void _initialize_mi_main(void)
Definition: mi-main.c:2980
enum register_status regcache_cooked_read(struct regcache *regcache, int regnum, gdb_byte *buf)
Definition: regcache.c:737
void mi_cmd_target_detach(char *command, char **argv, int argc)
Definition: mi-main.c:511
static void captured_mi_execute_command(struct ui_out *uiout, struct mi_parse *context)
Definition: mi-main.c:1980
struct trace_state_variable * create_trace_state_variable(const char *name)
Definition: tracepoint.c:300
#define VEC_address(T, V)
Definition: vec.h:369
static void show_mi_async_command(struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value)
Definition: mi-main.c:128
int argc
Definition: inferior.h:323
void mi_cmd_list_features(char *command, char **argv, int argc)
Definition: mi-main.c:1858
mi_cmd_argv_ftype * argv_func
Definition: mi-cmds.h:144
struct cleanup * make_cleanup_regcache_xfree(struct regcache *regcache)
Definition: regcache.c:263
static int * unique(int *b, int *e)
Definition: mi-main.c:627
struct inferior * add_inferior_with_spaces(void)
Definition: inferior.c:807
void mi_cmd_data_read_memory(char *command, char **argv, int argc)
Definition: mi-main.c:1399
struct inferior * find_inferior_id(int num)
Definition: inferior.c:342
int target_core_of_thread(ptid_t ptid)
Definition: target.c:3442
void ui_file_rewind(struct ui_file *file)
Definition: ui-file.c:204
struct inferior * current_inferior(void)
Definition: inferior.c:57
static void free_vector_of_osdata_items(splay_tree_value xvalue)
Definition: mi-main.c:742
int is_exited(ptid_t ptid)
Definition: thread.c:828
struct symtabs_and_lines decode_line_with_current_source(char *string, int flags)
Definition: linespec.c:2543
void ui_out_field_core_addr(struct ui_out *uiout, const char *fldname, struct gdbarch *gdbarch, CORE_ADDR address)
Definition: ui-out.c:499
struct value * parse_and_eval(const char *exp)
Definition: eval.c:124
void trace_save_tfile(const char *filename, int target_does_save)
Definition: tracefile.c:355
static void print_diff_now(struct mi_timestamp *start)
Definition: mi-main.c:2455
static PyObject * field_name(struct type *type, int field)
Definition: py-type.c:278
int has_exit_code
Definition: inferior.h:374
language
Definition: defs.h:167
int value_embedded_offset(struct value *value)
Definition: value.c:1388
const char * cmd
Definition: mi-cmds.h:132
int register_size(struct gdbarch *gdbarch, int regnum)
Definition: regcache.c:169
void mi_cmd_data_evaluate_expression(char *command, char **argv, int argc)
Definition: mi-main.c:1347
const char * message
#define VEC_cleanup(T)
Definition: vec.h:187
struct interp * top_level_interpreter(void)
Definition: interps.c:476
struct cleanup * save_current_space_and_thread(void)
Definition: progspace.c:448
static int run_one_inferior(struct inferior *inf, void *arg)
Definition: mi-main.c:414
struct trace_state_variable * find_trace_state_variable(const char *name)
Definition: tracepoint.c:313
struct type * value_type(const struct value *value)
Definition: value.c:1021
struct type * builtin_int64
Definition: gdbtypes.h:1520
static int mi_async_1
Definition: mi-main.c:112
void mi_cmd_remove_inferior(char *command, char **argv, int argc)
Definition: mi-main.c:1933
const char * get_osdata_column(struct osdata_item *item, const char *name)
Definition: osdata.c:273
Definition: ia64-tdep.c:84
int length
Definition: memrange.h:33
void bpstat_do_actions(void)
Definition: breakpoint.c:4668
LONGEST target_read(struct target_ops *ops, enum target_object object, const char *annex, gdb_byte *buf, ULONGEST offset, LONGEST len)
Definition: target.c:1590
enum gdb_rc gdb_list_thread_ids(struct ui_out *uiout, char **error_message)
Definition: thread.c:604
struct value * evaluate_type(struct expression *exp)
Definition: eval.c:170
void ui_out_field_string(struct ui_out *uiout, const char *fldname, const char *string)
Definition: ui-out.c:541
struct trace_state_variable * find_trace_state_variable_by_number(int number)
Definition: tracepoint.c:329
struct symtab_and_line * sals
Definition: symtab.h:1392
static void mi_execute_cli_command(const char *cmd, int args_p, const char *args)
Definition: mi-main.c:2299
enum language language
Definition: mi-parse.h:56
void mi_cmd_exec_continue(char *command, char **argv, int argc)
Definition: mi-main.c:346
int execution_direction
Definition: infrun.c:7561
void * arg
Definition: cleanups.c:43
void gdb_flush(struct ui_file *file)
Definition: ui-file.c:192
struct ui_out * current_uiout
Definition: ui-out.c:233
static int splay_tree_int_comparator(splay_tree_key xa, splay_tree_key xb)
Definition: mi-main.c:751
void write_memory_with_notification(CORE_ADDR memaddr, const bfd_byte *myaddr, ssize_t len)
Definition: corefile.c:402
int is_running(ptid_t ptid)
Definition: thread.c:834
int mi_async_p(void)
Definition: mi-main.c:141
static void mi_print_exception(const char *token, struct gdb_exception exception)
Definition: mi-main.c:2070
struct type * builtin_int8
Definition: gdbtypes.h:1514
void mi_cmd_thread_info(char *command, char **argv, int argc)
Definition: mi-main.c:595
int thread
Definition: mi-parse.h:51
int all
Definition: mi-parse.h:49
PTR xcalloc(size_t number, size_t size)
Definition: common-utils.c:71
void delete_inferior_1(struct inferior *todel, int silent)
Definition: inferior.c:191
enum bfd_endian byte_order
Definition: gdbarch.c:128
int current_interp_named_p(const char *interp_name)
Definition: interps.c:280
int has_stack_frames(void)
Definition: frame.c:1506
void mi_cmd_trace_start(char *command, char **argv, int argc)
Definition: mi-main.c:2655
enum print_values mi_parse_print_values(const char *name)
Definition: mi-parse.c:405
void mi_execute_command(const char *cmd, int from_tty)
Definition: mi-main.c:2091
struct thread_info * any_thread_of_process(int pid)
Definition: thread.c:510
struct cleanup * make_cleanup_restore_current_language(void)
Definition: utils.c:441
void val_print(struct type *type, const gdb_byte *valaddr, int embedded_offset, CORE_ADDR address, struct ui_file *stream, int recurse, const struct value *val, const struct value_print_options *options, const struct language_defn *language)
Definition: valprint.c:737
void error(const char *fmt,...)
Definition: errors.c:38
static int mi_async
Definition: mi-main.c:108
static int print_one_inferior(struct inferior *inferior, void *xdata)
Definition: mi-main.c:644
print_values
Definition: mi-cmds.h:25
char * args
Definition: mi-parse.h:46
enum gdb_rc gdb_thread_select(struct ui_out *uiout, char *tidstr, char **error_message)
Definition: thread.c:1707
mach_port_t mach_port_t name mach_port_t mach_port_t name error_t int int rusage_t pid_t pid
Definition: gnu-nat.c:1818
void prepare_execution_command(struct target_ops *target, int background)
Definition: infcmd.c:500
static void free_vector_of_ints(void *xvector)
Definition: mi-main.c:729
struct gdbarch * get_frame_arch(struct frame_info *this_frame)
Definition: frame.c:2535
int ext_lang_initialized_p(const struct extension_language_defn *extlang)
Definition: extension.c:178
void set_current_inferior(struct inferior *inf)
Definition: inferior.c:63
long long LONGEST
Definition: common-types.h:52
struct target_ops * beneath
Definition: target.h:431
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:175
void add_setshow_boolean_cmd(const char *name, enum command_class theclass, int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:541
static void output_cores(struct ui_out *uiout, const char *field_name, const char *xcores)
Definition: mi-main.c:713
void mi_cmd_exec_step_instruction(char *command, char **argv, int argc)
Definition: mi-main.c:199
void detach_command(char *args, int from_tty)
Definition: infcmd.c:2780
void mi_cmd_exec_next_instruction(char *command, char **argv, int argc)
Definition: mi-main.c:179
void mi_cmd_exec_step(char *command, char **argv, int argc)
Definition: mi-main.c:189
const char * name
Definition: tracepoint.h:49
void mi_cmd_data_read_memory_bytes(char *command, char **argv, int argc)
Definition: mi-main.c:1587
void mi_cmd_thread_select(char *command, char **argv, int argc)
Definition: mi-main.c:559
CORE_ADDR start
Definition: memrange.h:30
void return_command(char *, int)
Definition: stack.c:2372
struct ui_file * event_channel
Definition: mi-common.h:58