3 Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010
4 Free Software Foundation, Inc.
6 Contributed by Cygnus Solutions (a Red Hat company).
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 /* Work in progress. */
26 #include "arch-utils.h"
29 #include "gdb_string.h"
30 #include "exceptions.h"
32 #include "gdbthread.h"
35 #include "mi-getopt.h"
36 #include "mi-console.h"
40 #include "event-loop.h"
41 #include "event-top.h"
42 #include "gdbcore.h" /* For write_memory(). */
48 #include "mi-common.h"
53 #include "splay-tree.h"
54 #include "tracepoint.h"
59 #if defined HAVE_SYS_RESOURCE_H
60 #include <sys/resource.h>
73 struct ui_file *raw_stdout;
75 /* This is used to pass the current command timestamp
76 down to continuation routines. */
77 static struct mi_timestamp *current_command_ts;
79 static int do_timings = 0;
82 /* Few commands would like to know if options like --thread-group
83 were explicitly specified. This variable keeps the current
84 parsed command including all option, and make it possible. */
85 static struct mi_parse *current_context;
87 int running_result_record_printed = 1;
89 /* Flag indicating that the target has proceeded since the last
90 command was issued. */
93 extern void _initialize_mi_main (void);
94 static void mi_cmd_execute (struct mi_parse *parse);
96 static void mi_execute_cli_command (const char *cmd, int args_p,
98 static void mi_execute_async_cli_command (char *cli_command,
99 char **argv, int argc);
100 static int register_changed_p (int regnum, struct regcache *,
102 static void get_register (struct frame_info *, int regnum, int format);
104 /* Command implementations. FIXME: Is this libgdb? No. This is the MI
105 layer that calls libgdb. Any operation used in the below should be
108 static void timestamp (struct mi_timestamp *tv);
110 static void print_diff_now (struct mi_timestamp *start);
111 static void print_diff (struct mi_timestamp *start, struct mi_timestamp *end);
114 mi_cmd_gdb_exit (char *command, char **argv, int argc)
116 /* We have to print everything right here because we never return. */
118 fputs_unfiltered (current_token, raw_stdout);
119 fputs_unfiltered ("^exit\n", raw_stdout);
120 mi_out_put (uiout, raw_stdout);
121 gdb_flush (raw_stdout);
122 /* FIXME: The function called is not yet a formal libgdb function. */
123 quit_force (NULL, FROM_TTY);
127 mi_cmd_exec_next (char *command, char **argv, int argc)
129 /* FIXME: Should call a libgdb function, not a cli wrapper. */
130 if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
131 mi_execute_async_cli_command ("reverse-next", argv + 1, argc - 1);
133 mi_execute_async_cli_command ("next", argv, argc);
137 mi_cmd_exec_next_instruction (char *command, char **argv, int argc)
139 /* FIXME: Should call a libgdb function, not a cli wrapper. */
140 if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
141 mi_execute_async_cli_command ("reverse-nexti", argv + 1, argc - 1);
143 mi_execute_async_cli_command ("nexti", argv, argc);
147 mi_cmd_exec_step (char *command, char **argv, int argc)
149 /* FIXME: Should call a libgdb function, not a cli wrapper. */
150 if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
151 mi_execute_async_cli_command ("reverse-step", argv + 1, argc - 1);
153 mi_execute_async_cli_command ("step", argv, argc);
157 mi_cmd_exec_step_instruction (char *command, char **argv, int argc)
159 /* FIXME: Should call a libgdb function, not a cli wrapper. */
160 if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
161 mi_execute_async_cli_command ("reverse-stepi", argv + 1, argc - 1);
163 mi_execute_async_cli_command ("stepi", argv, argc);
167 mi_cmd_exec_finish (char *command, char **argv, int argc)
169 /* FIXME: Should call a libgdb function, not a cli wrapper. */
170 if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
171 mi_execute_async_cli_command ("reverse-finish", argv + 1, argc - 1);
173 mi_execute_async_cli_command ("finish", argv, argc);
177 mi_cmd_exec_return (char *command, char **argv, int argc)
179 /* This command doesn't really execute the target, it just pops the
180 specified number of frames. */
182 /* Call return_command with from_tty argument equal to 0 so as to
183 avoid being queried. */
184 return_command (*argv, 0);
186 /* Call return_command with from_tty argument equal to 0 so as to
187 avoid being queried. */
188 return_command (NULL, 0);
190 /* Because we have called return_command with from_tty = 0, we need
191 to print the frame here. */
192 print_stack_frame (get_selected_frame (NULL), 1, LOC_AND_ADDRESS);
196 mi_cmd_exec_jump (char *args, char **argv, int argc)
198 /* FIXME: Should call a libgdb function, not a cli wrapper. */
199 mi_execute_async_cli_command ("jump", argv, argc);
203 proceed_thread (struct thread_info *thread, int pid)
205 if (!is_stopped (thread->ptid))
208 if (pid != 0 && PIDGET (thread->ptid) != pid)
211 switch_to_thread (thread->ptid);
212 clear_proceed_status ();
213 proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 0);
218 proceed_thread_callback (struct thread_info *thread, void *arg)
220 int pid = *(int *)arg;
222 proceed_thread (thread, pid);
227 exec_continue (char **argv, int argc)
231 /* In non-stop mode, 'resume' always resumes a single thread. Therefore,
232 to resume all threads of the current inferior, or all threads in all
233 inferiors, we need to iterate over threads.
235 See comment on infcmd.c:proceed_thread_callback for rationale. */
236 if (current_context->all || current_context->thread_group != -1)
239 struct cleanup *back_to = make_cleanup_restore_current_thread ();
241 if (!current_context->all)
243 struct inferior *inf = find_inferior_id (current_context->thread_group);
246 iterate_over_threads (proceed_thread_callback, &pid);
247 do_cleanups (back_to);
256 struct cleanup *back_to = make_cleanup_restore_integer (&sched_multi);
258 if (current_context->all)
265 /* In all-stop mode, -exec-continue traditionally resumed either
266 all threads, or one thread, depending on the 'scheduler-locking'
267 variable. Let's continue to do the same. */
270 do_cleanups (back_to);
275 exec_direction_forward (void *notused)
277 execution_direction = EXEC_FORWARD;
281 exec_reverse_continue (char **argv, int argc)
283 enum exec_direction_kind dir = execution_direction;
284 struct cleanup *old_chain;
286 if (dir == EXEC_ERROR)
287 error (_("Target %s does not support this command."), target_shortname);
289 if (dir == EXEC_REVERSE)
290 error (_("Already in reverse mode."));
292 if (!target_can_execute_reverse)
293 error (_("Target %s does not support this command."), target_shortname);
295 old_chain = make_cleanup (exec_direction_forward, NULL);
296 execution_direction = EXEC_REVERSE;
297 exec_continue (argv, argc);
298 do_cleanups (old_chain);
302 mi_cmd_exec_continue (char *command, char **argv, int argc)
304 if (argc > 0 && strcmp (argv[0], "--reverse") == 0)
305 exec_reverse_continue (argv + 1, argc - 1);
307 exec_continue (argv, argc);
311 interrupt_thread_callback (struct thread_info *thread, void *arg)
313 int pid = *(int *)arg;
315 if (!is_running (thread->ptid))
318 if (PIDGET (thread->ptid) != pid)
321 target_stop (thread->ptid);
325 /* Interrupt the execution of the target. Note how we must play around
326 with the token variables, in order to display the current token in
327 the result of the interrupt command, and the previous execution
328 token when the target finally stops. See comments in
331 mi_cmd_exec_interrupt (char *command, char **argv, int argc)
333 /* In all-stop mode, everything stops, so we don't need to try
334 anything specific. */
337 interrupt_target_1 (0);
341 if (current_context->all)
343 /* This will interrupt all threads in all inferiors. */
344 interrupt_target_1 (1);
346 else if (current_context->thread_group != -1)
348 struct inferior *inf = find_inferior_id (current_context->thread_group);
350 iterate_over_threads (interrupt_thread_callback, &inf->pid);
354 /* Interrupt just the current thread -- either explicitly
355 specified via --thread or whatever was current before
356 MI command was sent. */
357 interrupt_target_1 (0);
362 run_one_inferior (struct inferior *inf, void *arg)
366 if (inf->pid != ptid_get_pid (inferior_ptid))
368 struct thread_info *tp;
370 tp = any_thread_of_process (inf->pid);
372 error (_("Inferior has no threads."));
374 switch_to_thread (tp->ptid);
379 set_current_inferior (inf);
380 switch_to_thread (null_ptid);
381 set_current_program_space (inf->pspace);
383 mi_execute_cli_command ("run", target_can_async_p (),
384 target_can_async_p () ? "&" : NULL);
389 mi_cmd_exec_run (char *command, char **argv, int argc)
391 if (current_context->all)
393 struct cleanup *back_to = save_current_space_and_thread ();
395 iterate_over_inferiors (run_one_inferior, NULL);
396 do_cleanups (back_to);
400 mi_execute_cli_command ("run", target_can_async_p (),
401 target_can_async_p () ? "&" : NULL);
407 find_thread_of_process (struct thread_info *ti, void *p)
411 if (PIDGET (ti->ptid) == pid && !is_exited (ti->ptid))
418 mi_cmd_target_detach (char *command, char **argv, int argc)
420 if (argc != 0 && argc != 1)
421 error ("Usage: -target-detach [thread-group]");
425 struct thread_info *tp;
427 int pid = strtol (argv[0], &end, 10);
430 error (_("Cannot parse thread group id '%s'"), argv[0]);
432 /* Pick any thread in the desired process. Current
433 target_detach deteches from the parent of inferior_ptid. */
434 tp = iterate_over_threads (find_thread_of_process, &pid);
436 error (_("Thread group is empty"));
438 switch_to_thread (tp->ptid);
441 detach_command (NULL, 0);
445 mi_cmd_thread_select (char *command, char **argv, int argc)
448 char *mi_error_message;
451 error ("mi_cmd_thread_select: USAGE: threadnum.");
453 rc = gdb_thread_select (uiout, argv[0], &mi_error_message);
455 if (rc == GDB_RC_FAIL)
457 make_cleanup (xfree, mi_error_message);
458 error ("%s", mi_error_message);
463 mi_cmd_thread_list_ids (char *command, char **argv, int argc)
466 char *mi_error_message;
469 error ("mi_cmd_thread_list_ids: No arguments required.");
471 rc = gdb_list_thread_ids (uiout, &mi_error_message);
473 if (rc == GDB_RC_FAIL)
475 make_cleanup (xfree, mi_error_message);
476 error ("%s", mi_error_message);
481 mi_cmd_thread_info (char *command, char **argv, int argc)
485 if (argc != 0 && argc != 1)
486 error ("Invalid MI command");
489 thread = atoi (argv[0]);
491 print_thread_info (uiout, thread, -1);
494 struct collect_cores_data
502 collect_cores (struct thread_info *ti, void *xdata)
504 struct collect_cores_data *data = xdata;
506 if (ptid_get_pid (ti->ptid) == data->pid)
508 int core = target_core_of_thread (ti->ptid);
511 VEC_safe_push (int, data->cores, core);
518 unique (int *b, int *e)
528 struct print_one_inferior_data
531 VEC (int) *inferiors;
535 print_one_inferior (struct inferior *inferior, void *xdata)
537 struct print_one_inferior_data *top_data = xdata;
539 if (VEC_empty (int, top_data->inferiors)
540 || bsearch (&(inferior->pid), VEC_address (int, top_data->inferiors),
541 VEC_length (int, top_data->inferiors), sizeof (int),
542 compare_positive_ints))
544 struct collect_cores_data data;
545 struct cleanup *back_to
546 = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
548 ui_out_field_fmt (uiout, "id", "i%d", inferior->num);
549 ui_out_field_string (uiout, "type", "process");
550 if (inferior->pid != 0)
551 ui_out_field_int (uiout, "pid", inferior->pid);
553 if (inferior->pspace->ebfd)
555 ui_out_field_string (uiout, "executable",
556 bfd_get_filename (inferior->pspace->ebfd));
560 if (inferior->pid != 0)
562 data.pid = inferior->pid;
563 iterate_over_threads (collect_cores, &data);
566 if (!VEC_empty (int, data.cores))
569 struct cleanup *back_to_2 =
570 make_cleanup_ui_out_list_begin_end (uiout, "cores");
572 qsort (VEC_address (int, data.cores),
573 VEC_length (int, data.cores), sizeof (int),
574 compare_positive_ints);
576 b = VEC_address (int, data.cores);
577 e = b + VEC_length (int, data.cores);
581 ui_out_field_int (uiout, NULL, *b);
583 do_cleanups (back_to_2);
586 if (top_data->recurse)
587 print_thread_info (uiout, -1, inferior->pid);
589 do_cleanups (back_to);
595 /* Output a field named 'cores' with a list as the value. The elements of
596 the list are obtained by splitting 'cores' on comma. */
599 output_cores (struct ui_out *uiout, const char *field_name, const char *xcores)
601 struct cleanup *back_to = make_cleanup_ui_out_list_begin_end (uiout,
603 char *cores = xstrdup (xcores);
606 make_cleanup (xfree, cores);
608 for (p = strtok (p, ","); p; p = strtok (NULL, ","))
609 ui_out_field_string (uiout, NULL, p);
611 do_cleanups (back_to);
615 free_vector_of_ints (void *xvector)
617 VEC (int) **vector = xvector;
619 VEC_free (int, *vector);
623 do_nothing (splay_tree_key k)
628 free_vector_of_osdata_items (splay_tree_value xvalue)
630 VEC (osdata_item_s) *value = (VEC (osdata_item_s) *) xvalue;
632 /* We don't free the items itself, it will be done separately. */
633 VEC_free (osdata_item_s, value);
637 splay_tree_int_comparator (splay_tree_key xa, splay_tree_key xb)
646 free_splay_tree (void *xt)
649 splay_tree_delete (t);
653 list_available_thread_groups (VEC (int) *ids, int recurse)
656 struct osdata_item *item;
659 /* This keeps a map from integer (pid) to VEC (struct osdata_item *)*
660 The vector contains information about all threads for the given pid.
661 This is assigned an initial value to avoid "may be used uninitialized"
663 splay_tree tree = NULL;
665 /* get_osdata will throw if it cannot return data. */
666 data = get_osdata ("processes");
667 make_cleanup_osdata_free (data);
671 struct osdata *threads = get_osdata ("threads");
673 make_cleanup_osdata_free (threads);
674 tree = splay_tree_new (splay_tree_int_comparator,
676 free_vector_of_osdata_items);
677 make_cleanup (free_splay_tree, tree);
680 VEC_iterate (osdata_item_s, threads->items,
684 const char *pid = get_osdata_column (item, "pid");
685 int pid_i = strtoul (pid, NULL, 0);
686 VEC (osdata_item_s) *vec = 0;
688 splay_tree_node n = splay_tree_lookup (tree, pid_i);
691 VEC_safe_push (osdata_item_s, vec, item);
692 splay_tree_insert (tree, pid_i, (splay_tree_value)vec);
696 vec = (VEC (osdata_item_s) *) n->value;
697 VEC_safe_push (osdata_item_s, vec, item);
698 n->value = (splay_tree_value) vec;
703 make_cleanup_ui_out_list_begin_end (uiout, "groups");
706 VEC_iterate (osdata_item_s, data->items,
710 struct cleanup *back_to;
712 const char *pid = get_osdata_column (item, "pid");
713 const char *cmd = get_osdata_column (item, "command");
714 const char *user = get_osdata_column (item, "user");
715 const char *cores = get_osdata_column (item, "cores");
717 int pid_i = strtoul (pid, NULL, 0);
719 /* At present, the target will return all available processes
720 and if information about specific ones was required, we filter
721 undesired processes here. */
722 if (ids && bsearch (&pid_i, VEC_address (int, ids),
723 VEC_length (int, ids),
724 sizeof (int), compare_positive_ints) == NULL)
728 back_to = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
730 ui_out_field_fmt (uiout, "id", "%s", pid);
731 ui_out_field_string (uiout, "type", "process");
733 ui_out_field_string (uiout, "description", cmd);
735 ui_out_field_string (uiout, "user", user);
737 output_cores (uiout, "cores", cores);
741 splay_tree_node n = splay_tree_lookup (tree, pid_i);
744 VEC (osdata_item_s) *children = (VEC (osdata_item_s) *) n->value;
745 struct osdata_item *child;
748 make_cleanup_ui_out_list_begin_end (uiout, "threads");
751 VEC_iterate (osdata_item_s, children, ix_child, child);
754 struct cleanup *back_to_2 =
755 make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
756 const char *tid = get_osdata_column (child, "tid");
757 const char *tcore = get_osdata_column (child, "core");
759 ui_out_field_string (uiout, "id", tid);
761 ui_out_field_string (uiout, "core", tcore);
763 do_cleanups (back_to_2);
768 do_cleanups (back_to);
773 mi_cmd_list_thread_groups (char *command, char **argv, int argc)
775 struct cleanup *back_to;
782 AVAILABLE_OPT, RECURSE_OPT
784 static struct mi_opt opts[] =
786 {"-available", AVAILABLE_OPT, 0},
787 {"-recurse", RECURSE_OPT, 1},
796 int opt = mi_getopt ("-list-thread-groups", argc, argv, opts,
801 switch ((enum opt) opt)
807 if (strcmp (optarg, "0") == 0)
809 else if (strcmp (optarg, "1") == 0)
812 error ("only '0' and '1' are valid values for the '--recurse' option");
817 for (; optind < argc; ++optind)
822 if (*(argv[optind]) != 'i')
823 error ("invalid syntax of group id '%s'", argv[optind]);
825 inf = strtoul (argv[optind] + 1, &end, 0);
828 error ("invalid syntax of group id '%s'", argv[optind]);
829 VEC_safe_push (int, ids, inf);
831 if (VEC_length (int, ids) > 1)
832 qsort (VEC_address (int, ids),
833 VEC_length (int, ids),
834 sizeof (int), compare_positive_ints);
836 back_to = make_cleanup (free_vector_of_ints, &ids);
840 list_available_thread_groups (ids, recurse);
842 else if (VEC_length (int, ids) == 1)
844 /* Local thread groups, single id. */
845 int id = *VEC_address (int, ids);
846 struct inferior *inf = find_inferior_id (id);
849 error ("Non-existent thread group id '%d'", id);
851 print_thread_info (uiout, -1, inf->pid);
855 struct print_one_inferior_data data;
857 data.recurse = recurse;
858 data.inferiors = ids;
860 /* Local thread groups. Either no explicit ids -- and we
861 print everything, or several explicit ids. In both cases,
862 we print more than one group, and have to use 'groups'
863 as the top-level element. */
864 make_cleanup_ui_out_list_begin_end (uiout, "groups");
865 update_thread_list ();
866 iterate_over_inferiors (print_one_inferior, &data);
869 do_cleanups (back_to);
873 mi_cmd_data_list_register_names (char *command, char **argv, int argc)
875 struct gdbarch *gdbarch;
878 struct cleanup *cleanup;
880 /* Note that the test for a valid register must include checking the
881 gdbarch_register_name because gdbarch_num_regs may be allocated for
882 the union of the register sets within a family of related processors.
883 In this case, some entries of gdbarch_register_name will change depending
884 upon the particular processor being debugged. */
886 gdbarch = get_current_arch ();
887 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
889 cleanup = make_cleanup_ui_out_list_begin_end (uiout, "register-names");
891 if (argc == 0) /* No args, just do all the regs. */
897 if (gdbarch_register_name (gdbarch, regnum) == NULL
898 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
899 ui_out_field_string (uiout, NULL, "");
901 ui_out_field_string (uiout, NULL,
902 gdbarch_register_name (gdbarch, regnum));
906 /* Else, list of register #s, just do listed regs. */
907 for (i = 0; i < argc; i++)
909 regnum = atoi (argv[i]);
910 if (regnum < 0 || regnum >= numregs)
911 error ("bad register number");
913 if (gdbarch_register_name (gdbarch, regnum) == NULL
914 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
915 ui_out_field_string (uiout, NULL, "");
917 ui_out_field_string (uiout, NULL,
918 gdbarch_register_name (gdbarch, regnum));
920 do_cleanups (cleanup);
924 mi_cmd_data_list_changed_registers (char *command, char **argv, int argc)
926 static struct regcache *this_regs = NULL;
927 struct regcache *prev_regs;
928 struct gdbarch *gdbarch;
929 int regnum, numregs, changed;
931 struct cleanup *cleanup;
933 /* The last time we visited this function, the current frame's register
934 contents were saved in THIS_REGS. Move THIS_REGS over to PREV_REGS,
935 and refresh THIS_REGS with the now-current register contents. */
937 prev_regs = this_regs;
938 this_regs = frame_save_as_regcache (get_selected_frame (NULL));
939 cleanup = make_cleanup_regcache_xfree (prev_regs);
941 /* Note that the test for a valid register must include checking the
942 gdbarch_register_name because gdbarch_num_regs may be allocated for
943 the union of the register sets within a family of related processors.
944 In this case, some entries of gdbarch_register_name will change depending
945 upon the particular processor being debugged. */
947 gdbarch = get_regcache_arch (this_regs);
948 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
950 make_cleanup_ui_out_list_begin_end (uiout, "changed-registers");
952 if (argc == 0) /* No args, just do all the regs. */
958 if (gdbarch_register_name (gdbarch, regnum) == NULL
959 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
961 changed = register_changed_p (regnum, prev_regs, this_regs);
963 error ("mi_cmd_data_list_changed_registers: Unable to read register contents.");
965 ui_out_field_int (uiout, NULL, regnum);
969 /* Else, list of register #s, just do listed regs. */
970 for (i = 0; i < argc; i++)
972 regnum = atoi (argv[i]);
976 && gdbarch_register_name (gdbarch, regnum) != NULL
977 && *gdbarch_register_name (gdbarch, regnum) != '\000')
979 changed = register_changed_p (regnum, prev_regs, this_regs);
981 error ("mi_cmd_data_list_register_change: Unable to read register contents.");
983 ui_out_field_int (uiout, NULL, regnum);
986 error ("bad register number");
988 do_cleanups (cleanup);
992 register_changed_p (int regnum, struct regcache *prev_regs,
993 struct regcache *this_regs)
995 struct gdbarch *gdbarch = get_regcache_arch (this_regs);
996 gdb_byte prev_buffer[MAX_REGISTER_SIZE];
997 gdb_byte this_buffer[MAX_REGISTER_SIZE];
999 /* Registers not valid in this frame return count as unchanged. */
1000 if (!regcache_valid_p (this_regs, regnum))
1003 /* First time through or after gdbarch change consider all registers as
1004 changed. Same for registers not valid in the previous frame. */
1005 if (!prev_regs || get_regcache_arch (prev_regs) != gdbarch
1006 || !regcache_valid_p (prev_regs, regnum))
1009 /* Get register contents and compare. */
1010 regcache_cooked_read (prev_regs, regnum, prev_buffer);
1011 regcache_cooked_read (this_regs, regnum, this_buffer);
1013 return memcmp (prev_buffer, this_buffer,
1014 register_size (gdbarch, regnum)) != 0;
1017 /* Return a list of register number and value pairs. The valid
1018 arguments expected are: a letter indicating the format in which to
1019 display the registers contents. This can be one of: x (hexadecimal), d
1020 (decimal), N (natural), t (binary), o (octal), r (raw). After the
1021 format argumetn there can be a sequence of numbers, indicating which
1022 registers to fetch the content of. If the format is the only argument,
1023 a list of all the registers with their values is returned. */
1025 mi_cmd_data_list_register_values (char *command, char **argv, int argc)
1027 struct frame_info *frame;
1028 struct gdbarch *gdbarch;
1029 int regnum, numregs, format;
1031 struct cleanup *list_cleanup, *tuple_cleanup;
1033 /* Note that the test for a valid register must include checking the
1034 gdbarch_register_name because gdbarch_num_regs may be allocated for
1035 the union of the register sets within a family of related processors.
1036 In this case, some entries of gdbarch_register_name will change depending
1037 upon the particular processor being debugged. */
1040 error ("mi_cmd_data_list_register_values: Usage: -data-list-register-values <format> [<regnum1>...<regnumN>]");
1042 format = (int) argv[0][0];
1044 frame = get_selected_frame (NULL);
1045 gdbarch = get_frame_arch (frame);
1046 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
1048 list_cleanup = make_cleanup_ui_out_list_begin_end (uiout, "register-values");
1050 if (argc == 1) /* No args, beside the format: do all the regs. */
1056 if (gdbarch_register_name (gdbarch, regnum) == NULL
1057 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
1059 tuple_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1060 ui_out_field_int (uiout, "number", regnum);
1061 get_register (frame, regnum, format);
1062 do_cleanups (tuple_cleanup);
1066 /* Else, list of register #s, just do listed regs. */
1067 for (i = 1; i < argc; i++)
1069 regnum = atoi (argv[i]);
1073 && gdbarch_register_name (gdbarch, regnum) != NULL
1074 && *gdbarch_register_name (gdbarch, regnum) != '\000')
1076 tuple_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1077 ui_out_field_int (uiout, "number", regnum);
1078 get_register (frame, regnum, format);
1079 do_cleanups (tuple_cleanup);
1082 error ("bad register number");
1084 do_cleanups (list_cleanup);
1087 /* Output one register's contents in the desired format. */
1089 get_register (struct frame_info *frame, int regnum, int format)
1091 struct gdbarch *gdbarch = get_frame_arch (frame);
1092 gdb_byte buffer[MAX_REGISTER_SIZE];
1096 enum lval_type lval;
1097 static struct ui_stream *stb = NULL;
1099 stb = ui_out_stream_new (uiout);
1104 frame_register (frame, regnum, &optim, &lval, &addr, &realnum, buffer);
1107 error ("Optimized out");
1112 char *ptr, buf[1024];
1116 for (j = 0; j < register_size (gdbarch, regnum); j++)
1118 int idx = gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG ?
1119 j : register_size (gdbarch, regnum) - 1 - j;
1121 sprintf (ptr, "%02x", (unsigned char) buffer[idx]);
1124 ui_out_field_string (uiout, "value", buf);
1125 /*fputs_filtered (buf, gdb_stdout); */
1129 struct value_print_options opts;
1131 get_formatted_print_options (&opts, format);
1133 val_print (register_type (gdbarch, regnum), buffer, 0, 0,
1134 stb->stream, 0, NULL, &opts, current_language);
1135 ui_out_field_stream (uiout, "value", stb);
1136 ui_out_stream_delete (stb);
1140 /* Write given values into registers. The registers and values are
1141 given as pairs. The corresponding MI command is
1142 -data-write-register-values <format> [<regnum1> <value1>...<regnumN> <valueN>]*/
1144 mi_cmd_data_write_register_values (char *command, char **argv, int argc)
1146 struct regcache *regcache;
1147 struct gdbarch *gdbarch;
1151 /* Note that the test for a valid register must include checking the
1152 gdbarch_register_name because gdbarch_num_regs may be allocated for
1153 the union of the register sets within a family of related processors.
1154 In this case, some entries of gdbarch_register_name will change depending
1155 upon the particular processor being debugged. */
1157 regcache = get_current_regcache ();
1158 gdbarch = get_regcache_arch (regcache);
1159 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
1162 error ("mi_cmd_data_write_register_values: Usage: -data-write-register-values <format> [<regnum1> <value1>...<regnumN> <valueN>]");
1164 format = (int) argv[0][0];
1166 if (!target_has_registers)
1167 error ("mi_cmd_data_write_register_values: No registers.");
1170 error ("mi_cmd_data_write_register_values: No regs and values specified.");
1173 error ("mi_cmd_data_write_register_values: Regs and vals are not in pairs.");
1175 for (i = 1; i < argc; i = i + 2)
1177 int regnum = atoi (argv[i]);
1179 if (regnum >= 0 && regnum < numregs
1180 && gdbarch_register_name (gdbarch, regnum)
1181 && *gdbarch_register_name (gdbarch, regnum))
1185 /* Get the value as a number. */
1186 value = parse_and_eval_address (argv[i + 1]);
1188 /* Write it down. */
1189 regcache_cooked_write_signed (regcache, regnum, value);
1192 error ("bad register number");
1196 /* Evaluate the value of the argument. The argument is an
1197 expression. If the expression contains spaces it needs to be
1198 included in double quotes. */
1200 mi_cmd_data_evaluate_expression (char *command, char **argv, int argc)
1202 struct expression *expr;
1203 struct cleanup *old_chain = NULL;
1205 struct ui_stream *stb = NULL;
1206 struct value_print_options opts;
1208 stb = ui_out_stream_new (uiout);
1212 ui_out_stream_delete (stb);
1213 error ("mi_cmd_data_evaluate_expression: Usage: -data-evaluate-expression expression");
1216 expr = parse_expression (argv[0]);
1218 old_chain = make_cleanup (free_current_contents, &expr);
1220 val = evaluate_expression (expr);
1222 /* Print the result of the expression evaluation. */
1223 get_user_print_options (&opts);
1225 common_val_print (val, stb->stream, 0, &opts, current_language);
1227 ui_out_field_stream (uiout, "value", stb);
1228 ui_out_stream_delete (stb);
1230 do_cleanups (old_chain);
1233 /* DATA-MEMORY-READ:
1235 ADDR: start address of data to be dumped.
1236 WORD-FORMAT: a char indicating format for the ``word''. See
1238 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
1239 NR_ROW: Number of rows.
1240 NR_COL: The number of colums (words per row).
1241 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
1242 ASCHAR for unprintable characters.
1244 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
1245 displayes them. Returns:
1247 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
1250 The number of bytes read is SIZE*ROW*COL. */
1253 mi_cmd_data_read_memory (char *command, char **argv, int argc)
1255 struct gdbarch *gdbarch = get_current_arch ();
1256 struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
1262 struct type *word_type;
1275 static struct mi_opt opts[] =
1277 {"o", OFFSET_OPT, 1},
1283 int opt = mi_getopt ("mi_cmd_data_read_memory", argc, argv, opts,
1288 switch ((enum opt) opt)
1291 offset = atol (optarg);
1298 if (argc < 5 || argc > 6)
1299 error ("mi_cmd_data_read_memory: Usage: ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR].");
1301 /* Extract all the arguments. */
1303 /* Start address of the memory dump. */
1304 addr = parse_and_eval_address (argv[0]) + offset;
1305 /* The format character to use when displaying a memory word. See
1306 the ``x'' command. */
1307 word_format = argv[1][0];
1308 /* The size of the memory word. */
1309 word_size = atol (argv[2]);
1313 word_type = builtin_type (gdbarch)->builtin_int8;
1317 word_type = builtin_type (gdbarch)->builtin_int16;
1321 word_type = builtin_type (gdbarch)->builtin_int32;
1325 word_type = builtin_type (gdbarch)->builtin_int64;
1329 word_type = builtin_type (gdbarch)->builtin_int8;
1332 /* The number of rows. */
1333 nr_rows = atol (argv[3]);
1335 error ("mi_cmd_data_read_memory: invalid number of rows.");
1337 /* Number of bytes per row. */
1338 nr_cols = atol (argv[4]);
1340 error ("mi_cmd_data_read_memory: invalid number of columns.");
1342 /* The un-printable character when printing ascii. */
1348 /* Create a buffer and read it in. */
1349 total_bytes = word_size * nr_rows * nr_cols;
1350 mbuf = xcalloc (total_bytes, 1);
1351 make_cleanup (xfree, mbuf);
1353 /* Dispatch memory reads to the topmost target, not the flattened
1355 nr_bytes = target_read (current_target.beneath,
1356 TARGET_OBJECT_MEMORY, NULL, mbuf,
1359 error ("Unable to read memory.");
1361 /* Output the header information. */
1362 ui_out_field_core_addr (uiout, "addr", gdbarch, addr);
1363 ui_out_field_int (uiout, "nr-bytes", nr_bytes);
1364 ui_out_field_int (uiout, "total-bytes", total_bytes);
1365 ui_out_field_core_addr (uiout, "next-row",
1366 gdbarch, addr + word_size * nr_cols);
1367 ui_out_field_core_addr (uiout, "prev-row",
1368 gdbarch, addr - word_size * nr_cols);
1369 ui_out_field_core_addr (uiout, "next-page", gdbarch, addr + total_bytes);
1370 ui_out_field_core_addr (uiout, "prev-page", gdbarch, addr - total_bytes);
1372 /* Build the result as a two dimentional table. */
1374 struct ui_stream *stream = ui_out_stream_new (uiout);
1375 struct cleanup *cleanup_list_memory;
1379 cleanup_list_memory = make_cleanup_ui_out_list_begin_end (uiout, "memory");
1380 for (row = 0, row_byte = 0;
1382 row++, row_byte += nr_cols * word_size)
1386 struct cleanup *cleanup_tuple;
1387 struct cleanup *cleanup_list_data;
1388 struct value_print_options opts;
1390 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1391 ui_out_field_core_addr (uiout, "addr", gdbarch, addr + row_byte);
1392 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr + row_byte); */
1393 cleanup_list_data = make_cleanup_ui_out_list_begin_end (uiout, "data");
1394 get_formatted_print_options (&opts, word_format);
1395 for (col = 0, col_byte = row_byte;
1397 col++, col_byte += word_size)
1399 if (col_byte + word_size > nr_bytes)
1401 ui_out_field_string (uiout, NULL, "N/A");
1405 ui_file_rewind (stream->stream);
1406 print_scalar_formatted (mbuf + col_byte, word_type, &opts,
1407 word_asize, stream->stream);
1408 ui_out_field_stream (uiout, NULL, stream);
1411 do_cleanups (cleanup_list_data);
1416 ui_file_rewind (stream->stream);
1417 for (byte = row_byte; byte < row_byte + word_size * nr_cols; byte++)
1419 if (byte >= nr_bytes)
1421 fputc_unfiltered ('X', stream->stream);
1423 else if (mbuf[byte] < 32 || mbuf[byte] > 126)
1425 fputc_unfiltered (aschar, stream->stream);
1428 fputc_unfiltered (mbuf[byte], stream->stream);
1430 ui_out_field_stream (uiout, "ascii", stream);
1432 do_cleanups (cleanup_tuple);
1434 ui_out_stream_delete (stream);
1435 do_cleanups (cleanup_list_memory);
1437 do_cleanups (cleanups);
1441 mi_cmd_data_read_memory_bytes (char *command, char **argv, int argc)
1443 struct gdbarch *gdbarch = get_current_arch ();
1444 struct cleanup *cleanups;
1447 memory_read_result_s *read_result;
1449 VEC(memory_read_result_s) *result;
1457 static struct mi_opt opts[] =
1459 {"o", OFFSET_OPT, 1},
1465 int opt = mi_getopt ("mi_cmd_data_read_memory_bytes", argc, argv, opts,
1469 switch ((enum opt) opt)
1472 offset = atol (optarg);
1480 error ("Usage: [ -o OFFSET ] ADDR LENGTH.");
1482 addr = parse_and_eval_address (argv[0]) + offset;
1483 length = atol (argv[1]);
1485 result = read_memory_robust (current_target.beneath, addr, length);
1487 cleanups = make_cleanup (free_memory_read_result_vector, result);
1489 if (VEC_length (memory_read_result_s, result) == 0)
1490 error ("Unable to read memory.");
1492 make_cleanup_ui_out_list_begin_end (uiout, "memory");
1494 VEC_iterate (memory_read_result_s, result, ix, read_result);
1497 struct cleanup *t = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1501 ui_out_field_core_addr (uiout, "begin", gdbarch, read_result->begin);
1502 ui_out_field_core_addr (uiout, "offset", gdbarch, read_result->begin
1504 ui_out_field_core_addr (uiout, "end", gdbarch, read_result->end);
1506 data = xmalloc ((read_result->end - read_result->begin) * 2 + 1);
1508 for (i = 0, p = data;
1509 i < (read_result->end - read_result->begin);
1512 sprintf (p, "%02x", read_result->data[i]);
1514 ui_out_field_string (uiout, "contents", data);
1518 do_cleanups (cleanups);
1522 /* DATA-MEMORY-WRITE:
1524 COLUMN_OFFSET: optional argument. Must be preceeded by '-o'. The
1525 offset from the beginning of the memory grid row where the cell to
1527 ADDR: start address of the row in the memory grid where the memory
1528 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
1529 the location to write to.
1530 FORMAT: a char indicating format for the ``word''. See
1532 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
1533 VALUE: value to be written into the memory address.
1535 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1539 mi_cmd_data_write_memory (char *command, char **argv, int argc)
1541 struct gdbarch *gdbarch = get_current_arch ();
1542 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1546 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1547 enough when using a compiler other than GCC. */
1550 struct cleanup *old_chain;
1558 static struct mi_opt opts[] =
1560 {"o", OFFSET_OPT, 1},
1566 int opt = mi_getopt ("mi_cmd_data_write_memory", argc, argv, opts,
1571 switch ((enum opt) opt)
1574 offset = atol (optarg);
1582 error ("mi_cmd_data_write_memory: Usage: [-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE.");
1584 /* Extract all the arguments. */
1585 /* Start address of the memory dump. */
1586 addr = parse_and_eval_address (argv[0]);
1587 /* The format character to use when displaying a memory word. See
1588 the ``x'' command. */
1589 word_format = argv[1][0];
1590 /* The size of the memory word. */
1591 word_size = atol (argv[2]);
1593 /* Calculate the real address of the write destination. */
1594 addr += (offset * word_size);
1596 /* Get the value as a number. */
1597 value = parse_and_eval_address (argv[3]);
1598 /* Get the value into an array. */
1599 buffer = xmalloc (word_size);
1600 old_chain = make_cleanup (xfree, buffer);
1601 store_signed_integer (buffer, word_size, byte_order, value);
1602 /* Write it down to memory. */
1603 write_memory (addr, buffer, word_size);
1604 /* Free the buffer. */
1605 do_cleanups (old_chain);
1608 /* DATA-MEMORY-WRITE-RAW:
1611 DATA: string of bytes to write at that address. */
1613 mi_cmd_data_write_memory_bytes (char *command, char **argv, int argc)
1619 struct cleanup *back_to;
1622 error ("Usage: ADDR DATA.");
1624 addr = parse_and_eval_address (argv[0]);
1626 len = strlen (cdata)/2;
1628 data = xmalloc (len);
1629 back_to = make_cleanup (xfree, data);
1631 for (i = 0; i < len; ++i)
1634 sscanf (cdata + i * 2, "%02x", &x);
1635 data[i] = (gdb_byte)x;
1638 r = target_write_memory (addr, data, len);
1640 error (_("Could not write memory"));
1642 do_cleanups (back_to);
1647 mi_cmd_enable_timings (char *command, char **argv, int argc)
1653 if (strcmp (argv[0], "yes") == 0)
1655 else if (strcmp (argv[0], "no") == 0)
1666 error ("mi_cmd_enable_timings: Usage: %s {yes|no}", command);
1670 mi_cmd_list_features (char *command, char **argv, int argc)
1674 struct cleanup *cleanup = NULL;
1676 cleanup = make_cleanup_ui_out_list_begin_end (uiout, "features");
1677 ui_out_field_string (uiout, NULL, "frozen-varobjs");
1678 ui_out_field_string (uiout, NULL, "pending-breakpoints");
1679 ui_out_field_string (uiout, NULL, "thread-info");
1680 ui_out_field_string (uiout, NULL, "data-read-memory-bytes");
1683 ui_out_field_string (uiout, NULL, "python");
1686 do_cleanups (cleanup);
1690 error ("-list-features should be passed no arguments");
1694 mi_cmd_list_target_features (char *command, char **argv, int argc)
1698 struct cleanup *cleanup = NULL;
1700 cleanup = make_cleanup_ui_out_list_begin_end (uiout, "features");
1701 if (target_can_async_p ())
1702 ui_out_field_string (uiout, NULL, "async");
1704 do_cleanups (cleanup);
1708 error ("-list-target-features should be passed no arguments");
1712 mi_cmd_add_inferior (char *command, char **argv, int argc)
1714 struct inferior *inf;
1717 error (_("-add-inferior should be passed no arguments"));
1719 inf = add_inferior_with_spaces ();
1721 ui_out_field_fmt (uiout, "inferior", "i%d", inf->num);
1725 mi_cmd_remove_inferior (char *command, char **argv, int argc)
1728 struct inferior *inf;
1731 error ("-remove-inferior should be passed a single argument");
1733 if (sscanf (argv[0], "i%d", &id) != 1)
1734 error ("the thread group id is syntactically invalid");
1736 inf = find_inferior_id (id);
1738 error ("the specified thread group does not exist");
1740 delete_inferior_1 (inf, 1 /* silent */);
1745 /* Execute a command within a safe environment.
1746 Return <0 for error; >=0 for ok.
1748 args->action will tell mi_execute_command what action
1749 to perfrom after the given command has executed (display/suppress
1750 prompt, display error). */
1753 captured_mi_execute_command (struct ui_out *uiout, void *data)
1755 struct cleanup *cleanup;
1756 struct mi_parse *context = (struct mi_parse *) data;
1759 current_command_ts = context->cmd_start;
1761 current_token = xstrdup (context->token);
1762 cleanup = make_cleanup (free_current_contents, ¤t_token);
1764 running_result_record_printed = 0;
1766 switch (context->op)
1769 /* A MI command was read from the input stream. */
1771 /* FIXME: gdb_???? */
1772 fprintf_unfiltered (raw_stdout, " token=`%s' command=`%s' args=`%s'\n",
1773 context->token, context->command, context->args);
1776 mi_cmd_execute (context);
1778 /* Print the result if there were no errors.
1780 Remember that on the way out of executing a command, you have
1781 to directly use the mi_interp's uiout, since the command could
1782 have reset the interpreter, in which case the current uiout
1783 will most likely crash in the mi_out_* routines. */
1784 if (!running_result_record_printed)
1786 fputs_unfiltered (context->token, raw_stdout);
1787 /* There's no particularly good reason why target-connect results
1788 in not ^done. Should kill ^connected for MI3. */
1789 fputs_unfiltered (strcmp (context->command, "target-select") == 0
1790 ? "^connected" : "^done", raw_stdout);
1791 mi_out_put (uiout, raw_stdout);
1792 mi_out_rewind (uiout);
1793 mi_print_timing_maybe ();
1794 fputs_unfiltered ("\n", raw_stdout);
1797 /* The command does not want anything to be printed. In that
1798 case, the command probably should not have written anything
1799 to uiout, but in case it has written something, discard it. */
1800 mi_out_rewind (uiout);
1807 /* A CLI command was read from the input stream. */
1808 /* This "feature" will be removed as soon as we have a
1809 complete set of mi commands. */
1810 /* Echo the command on the console. */
1811 fprintf_unfiltered (gdb_stdlog, "%s\n", context->command);
1812 /* Call the "console" interpreter. */
1813 argv[0] = "console";
1814 argv[1] = context->command;
1815 mi_cmd_interpreter_exec ("-interpreter-exec", argv, 2);
1817 /* If we changed interpreters, DON'T print out anything. */
1818 if (current_interp_named_p (INTERP_MI)
1819 || current_interp_named_p (INTERP_MI1)
1820 || current_interp_named_p (INTERP_MI2)
1821 || current_interp_named_p (INTERP_MI3))
1823 if (!running_result_record_printed)
1825 fputs_unfiltered (context->token, raw_stdout);
1826 fputs_unfiltered ("^done", raw_stdout);
1827 mi_out_put (uiout, raw_stdout);
1828 mi_out_rewind (uiout);
1829 mi_print_timing_maybe ();
1830 fputs_unfiltered ("\n", raw_stdout);
1833 mi_out_rewind (uiout);
1840 do_cleanups (cleanup);
1847 mi_execute_command (char *cmd, int from_tty)
1849 struct mi_parse *command;
1851 /* This is to handle EOF (^D). We just quit gdb. */
1852 /* FIXME: we should call some API function here. */
1854 quit_force (NULL, from_tty);
1856 target_log_command (cmd);
1858 command = mi_parse (cmd);
1860 if (command != NULL)
1862 struct gdb_exception result;
1863 ptid_t previous_ptid = inferior_ptid;
1867 command->cmd_start = (struct mi_timestamp *)
1868 xmalloc (sizeof (struct mi_timestamp));
1869 timestamp (command->cmd_start);
1872 result = catch_exception (uiout, captured_mi_execute_command, command,
1874 if (result.reason < 0)
1876 /* The command execution failed and error() was called
1878 fputs_unfiltered (command->token, raw_stdout);
1879 fputs_unfiltered ("^error,msg=\"", raw_stdout);
1880 if (result.message == NULL)
1881 fputs_unfiltered ("unknown error", raw_stdout);
1883 fputstr_unfiltered (result.message, '"', raw_stdout);
1884 fputs_unfiltered ("\"\n", raw_stdout);
1885 mi_out_rewind (uiout);
1888 bpstat_do_actions ();
1890 if (/* The notifications are only output when the top-level
1891 interpreter (specified on the command line) is MI. */
1892 ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ()))
1893 /* Don't try report anything if there are no threads --
1894 the program is dead. */
1895 && thread_count () != 0
1896 /* -thread-select explicitly changes thread. If frontend uses that
1897 internally, we don't want to emit =thread-selected, since
1898 =thread-selected is supposed to indicate user's intentions. */
1899 && strcmp (command->command, "thread-select") != 0)
1901 struct mi_interp *mi = top_level_interpreter_data ();
1902 int report_change = 0;
1904 if (command->thread == -1)
1906 report_change = (!ptid_equal (previous_ptid, null_ptid)
1907 && !ptid_equal (inferior_ptid, previous_ptid)
1908 && !ptid_equal (inferior_ptid, null_ptid));
1910 else if (!ptid_equal (inferior_ptid, null_ptid))
1912 struct thread_info *ti = inferior_thread ();
1914 report_change = (ti->num != command->thread);
1919 struct thread_info *ti = inferior_thread ();
1921 target_terminal_ours ();
1922 fprintf_unfiltered (mi->event_channel,
1923 "thread-selected,id=\"%d\"",
1925 gdb_flush (mi->event_channel);
1929 mi_parse_free (command);
1932 fputs_unfiltered ("(gdb) \n", raw_stdout);
1933 gdb_flush (raw_stdout);
1934 /* Print any buffered hook code. */
1939 mi_cmd_execute (struct mi_parse *parse)
1941 struct cleanup *cleanup;
1943 prepare_execute_command ();
1945 cleanup = make_cleanup (null_cleanup, NULL);
1947 if (parse->all && parse->thread_group != -1)
1948 error (_("Cannot specify --thread-group together with --all"));
1950 if (parse->all && parse->thread != -1)
1951 error (_("Cannot specify --thread together with --all"));
1953 if (parse->thread_group != -1 && parse->thread != -1)
1954 error (_("Cannot specify --thread together with --thread-group"));
1956 if (parse->frame != -1 && parse->thread == -1)
1957 error (_("Cannot specify --frame without --thread"));
1959 if (parse->thread_group != -1)
1961 struct inferior *inf = find_inferior_id (parse->thread_group);
1962 struct thread_info *tp = 0;
1965 error (_("Invalid thread group for the --thread-group option"));
1967 set_current_inferior (inf);
1968 /* This behaviour means that if --thread-group option identifies
1969 an inferior with multiple threads, then a random one will be picked.
1970 This is not a problem -- frontend should always provide --thread if
1971 it wishes to operate on a specific thread. */
1973 tp = any_thread_of_process (inf->pid);
1974 switch_to_thread (tp ? tp->ptid : null_ptid);
1975 set_current_program_space (inf->pspace);
1978 if (parse->thread != -1)
1980 struct thread_info *tp = find_thread_id (parse->thread);
1983 error (_("Invalid thread id: %d"), parse->thread);
1985 if (is_exited (tp->ptid))
1986 error (_("Thread id: %d has terminated"), parse->thread);
1988 switch_to_thread (tp->ptid);
1991 if (parse->frame != -1)
1993 struct frame_info *fid;
1994 int frame = parse->frame;
1996 fid = find_relative_frame (get_current_frame (), &frame);
1998 /* find_relative_frame was successful */
2001 error (_("Invalid frame id: %d"), frame);
2004 current_context = parse;
2006 if (parse->cmd->argv_func != NULL)
2007 parse->cmd->argv_func (parse->command, parse->argv, parse->argc);
2008 else if (parse->cmd->cli.cmd != 0)
2010 /* FIXME: DELETE THIS. */
2011 /* The operation is still implemented by a cli command. */
2012 /* Must be a synchronous one. */
2013 mi_execute_cli_command (parse->cmd->cli.cmd, parse->cmd->cli.args_p,
2018 /* FIXME: DELETE THIS. */
2019 struct ui_file *stb;
2021 stb = mem_fileopen ();
2023 fputs_unfiltered ("Undefined mi command: ", stb);
2024 fputstr_unfiltered (parse->command, '"', stb);
2025 fputs_unfiltered (" (missing implementation)", stb);
2027 make_cleanup_ui_file_delete (stb);
2030 do_cleanups (cleanup);
2033 /* FIXME: This is just a hack so we can get some extra commands going.
2034 We don't want to channel things through the CLI, but call libgdb directly.
2035 Use only for synchronous commands. */
2038 mi_execute_cli_command (const char *cmd, int args_p, const char *args)
2042 struct cleanup *old_cleanups;
2046 run = xstrprintf ("%s %s", cmd, args);
2048 run = xstrdup (cmd);
2050 /* FIXME: gdb_???? */
2051 fprintf_unfiltered (gdb_stdout, "cli=%s run=%s\n",
2053 old_cleanups = make_cleanup (xfree, run);
2054 execute_command ( /*ui */ run, 0 /*from_tty */ );
2055 do_cleanups (old_cleanups);
2061 mi_execute_async_cli_command (char *cli_command, char **argv, int argc)
2063 struct cleanup *old_cleanups;
2066 if (target_can_async_p ())
2067 run = xstrprintf ("%s %s&", cli_command, argc ? *argv : "");
2069 run = xstrprintf ("%s %s", cli_command, argc ? *argv : "");
2070 old_cleanups = make_cleanup (xfree, run);
2072 execute_command ( /*ui */ run, 0 /*from_tty */ );
2074 if (target_can_async_p ())
2076 /* If we're not executing, an exception should have been throw. */
2077 gdb_assert (is_running (inferior_ptid));
2078 do_cleanups (old_cleanups);
2082 /* Do this before doing any printing. It would appear that some
2083 print code leaves garbage around in the buffer. */
2084 do_cleanups (old_cleanups);
2089 mi_load_progress (const char *section_name,
2090 unsigned long sent_so_far,
2091 unsigned long total_section,
2092 unsigned long total_sent,
2093 unsigned long grand_total)
2095 struct timeval time_now, delta, update_threshold;
2096 static struct timeval last_update;
2097 static char *previous_sect_name = NULL;
2099 struct ui_out *saved_uiout;
2101 /* This function is called through deprecated_show_load_progress
2102 which means uiout may not be correct. Fix it for the duration
2103 of this function. */
2104 saved_uiout = uiout;
2106 if (current_interp_named_p (INTERP_MI)
2107 || current_interp_named_p (INTERP_MI2))
2108 uiout = mi_out_new (2);
2109 else if (current_interp_named_p (INTERP_MI1))
2110 uiout = mi_out_new (1);
2111 else if (current_interp_named_p (INTERP_MI3))
2112 uiout = mi_out_new (3);
2116 update_threshold.tv_sec = 0;
2117 update_threshold.tv_usec = 500000;
2118 gettimeofday (&time_now, NULL);
2120 delta.tv_usec = time_now.tv_usec - last_update.tv_usec;
2121 delta.tv_sec = time_now.tv_sec - last_update.tv_sec;
2123 if (delta.tv_usec < 0)
2126 delta.tv_usec += 1000000L;
2129 new_section = (previous_sect_name ?
2130 strcmp (previous_sect_name, section_name) : 1);
2133 struct cleanup *cleanup_tuple;
2135 xfree (previous_sect_name);
2136 previous_sect_name = xstrdup (section_name);
2139 fputs_unfiltered (current_token, raw_stdout);
2140 fputs_unfiltered ("+download", raw_stdout);
2141 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
2142 ui_out_field_string (uiout, "section", section_name);
2143 ui_out_field_int (uiout, "section-size", total_section);
2144 ui_out_field_int (uiout, "total-size", grand_total);
2145 do_cleanups (cleanup_tuple);
2146 mi_out_put (uiout, raw_stdout);
2147 fputs_unfiltered ("\n", raw_stdout);
2148 gdb_flush (raw_stdout);
2151 if (delta.tv_sec >= update_threshold.tv_sec &&
2152 delta.tv_usec >= update_threshold.tv_usec)
2154 struct cleanup *cleanup_tuple;
2156 last_update.tv_sec = time_now.tv_sec;
2157 last_update.tv_usec = time_now.tv_usec;
2159 fputs_unfiltered (current_token, raw_stdout);
2160 fputs_unfiltered ("+download", raw_stdout);
2161 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
2162 ui_out_field_string (uiout, "section", section_name);
2163 ui_out_field_int (uiout, "section-sent", sent_so_far);
2164 ui_out_field_int (uiout, "section-size", total_section);
2165 ui_out_field_int (uiout, "total-sent", total_sent);
2166 ui_out_field_int (uiout, "total-size", grand_total);
2167 do_cleanups (cleanup_tuple);
2168 mi_out_put (uiout, raw_stdout);
2169 fputs_unfiltered ("\n", raw_stdout);
2170 gdb_flush (raw_stdout);
2174 uiout = saved_uiout;
2178 timestamp (struct mi_timestamp *tv)
2180 gettimeofday (&tv->wallclock, NULL);
2181 #ifdef HAVE_GETRUSAGE
2182 getrusage (RUSAGE_SELF, &rusage);
2183 tv->utime.tv_sec = rusage.ru_utime.tv_sec;
2184 tv->utime.tv_usec = rusage.ru_utime.tv_usec;
2185 tv->stime.tv_sec = rusage.ru_stime.tv_sec;
2186 tv->stime.tv_usec = rusage.ru_stime.tv_usec;
2189 long usec = get_run_time ();
2191 tv->utime.tv_sec = usec/1000000L;
2192 tv->utime.tv_usec = usec - 1000000L*tv->utime.tv_sec;
2193 tv->stime.tv_sec = 0;
2194 tv->stime.tv_usec = 0;
2200 print_diff_now (struct mi_timestamp *start)
2202 struct mi_timestamp now;
2205 print_diff (start, &now);
2209 mi_print_timing_maybe (void)
2211 /* If the command is -enable-timing then do_timings may be
2212 true whilst current_command_ts is not initialized. */
2213 if (do_timings && current_command_ts)
2214 print_diff_now (current_command_ts);
2218 timeval_diff (struct timeval start, struct timeval end)
2220 return ((end.tv_sec - start.tv_sec) * 1000000L)
2221 + (end.tv_usec - start.tv_usec);
2225 print_diff (struct mi_timestamp *start, struct mi_timestamp *end)
2229 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
2230 timeval_diff (start->wallclock, end->wallclock) / 1000000.0,
2231 timeval_diff (start->utime, end->utime) / 1000000.0,
2232 timeval_diff (start->stime, end->stime) / 1000000.0);
2236 mi_cmd_trace_define_variable (char *command, char **argv, int argc)
2238 struct expression *expr;
2239 struct cleanup *back_to;
2240 LONGEST initval = 0;
2241 struct trace_state_variable *tsv;
2244 if (argc != 1 && argc != 2)
2245 error (_("Usage: -trace-define-variable VARIABLE [VALUE]"));
2247 expr = parse_expression (argv[0]);
2248 back_to = make_cleanup (xfree, expr);
2250 if (expr->nelts == 3 && expr->elts[0].opcode == OP_INTERNALVAR)
2252 struct internalvar *intvar = expr->elts[1].internalvar;
2255 name = internalvar_name (intvar);
2258 if (!name || *name == '\0')
2259 error (_("Invalid name of trace variable"));
2261 tsv = find_trace_state_variable (name);
2263 tsv = create_trace_state_variable (name);
2266 initval = value_as_long (parse_and_eval (argv[1]));
2268 tsv->initial_value = initval;
2270 do_cleanups (back_to);
2274 mi_cmd_trace_list_variables (char *command, char **argv, int argc)
2277 error (_("-trace-list-variables: no arguments are allowed"));
2279 tvariables_info_1 ();
2283 mi_cmd_trace_find (char *command, char **argv, int argc)
2288 error (_("trace selection mode is required"));
2292 if (strcmp (mode, "none") == 0)
2294 tfind_1 (tfind_number, -1, 0, 0, 0);
2298 if (current_trace_status ()->running)
2299 error (_("May not look at trace frames while trace is running."));
2301 if (strcmp (mode, "frame-number") == 0)
2304 error (_("frame number is required"));
2305 tfind_1 (tfind_number, atoi (argv[1]), 0, 0, 0);
2307 else if (strcmp (mode, "tracepoint-number") == 0)
2310 error (_("tracepoint number is required"));
2311 tfind_1 (tfind_tp, atoi (argv[1]), 0, 0, 0);
2313 else if (strcmp (mode, "pc") == 0)
2316 error (_("PC is required"));
2317 tfind_1 (tfind_pc, 0, parse_and_eval_address (argv[1]), 0, 0);
2319 else if (strcmp (mode, "pc-inside-range") == 0)
2322 error (_("Start and end PC are required"));
2323 tfind_1 (tfind_range, 0, parse_and_eval_address (argv[1]),
2324 parse_and_eval_address (argv[2]), 0);
2326 else if (strcmp (mode, "pc-outside-range") == 0)
2329 error (_("Start and end PC are required"));
2330 tfind_1 (tfind_outside, 0, parse_and_eval_address (argv[1]),
2331 parse_and_eval_address (argv[2]), 0);
2333 else if (strcmp (mode, "line") == 0)
2335 struct symtabs_and_lines sals;
2336 struct symtab_and_line sal;
2337 static CORE_ADDR start_pc, end_pc;
2338 struct cleanup *back_to;
2341 error (_("Line is required"));
2343 sals = decode_line_spec (argv[1], 1);
2344 back_to = make_cleanup (xfree, sals.sals);
2348 if (sal.symtab == 0)
2349 error (_("Could not find the specified line"));
2351 if (sal.line > 0 && find_line_pc_range (sal, &start_pc, &end_pc))
2352 tfind_1 (tfind_range, 0, start_pc, end_pc - 1, 0);
2354 error (_("Could not find the specified line"));
2356 do_cleanups (back_to);
2359 error (_("Invalid mode '%s'"), mode);
2361 if (has_stack_frames () || get_traceframe_number () >= 0)
2363 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
2368 mi_cmd_trace_save (char *command, char **argv, int argc)
2370 int target_saves = 0;
2373 if (argc != 1 && argc != 2)
2374 error (_("Usage: -trace-save [-r] filename"));
2379 if (strcmp (argv[0], "-r") == 0)
2382 error (_("Invalid option: %s"), argv[0]);
2389 trace_save (filename, target_saves);
2394 mi_cmd_trace_start (char *command, char **argv, int argc)
2400 mi_cmd_trace_status (char *command, char **argv, int argc)
2402 trace_status_mi (0);
2406 mi_cmd_trace_stop (char *command, char **argv, int argc)
2409 trace_status_mi (1);