3 Copyright (C) 2000-2013 Free Software Foundation, Inc.
5 Contributed by Cygnus Solutions (a Red Hat company).
7 This file is part of GDB.
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.
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.
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/>. */
23 #include "arch-utils.h"
26 #include "gdb_string.h"
27 #include "exceptions.h"
29 #include "gdbthread.h"
32 #include "mi-getopt.h"
33 #include "mi-console.h"
37 #include "event-loop.h"
38 #include "event-top.h"
39 #include "gdbcore.h" /* For write_memory(). */
45 #include "mi-common.h"
50 #include "splay-tree.h"
51 #include "tracepoint.h"
59 #if defined HAVE_SYS_RESOURCE_H
60 #include <sys/resource.h>
74 struct ui_file *raw_stdout;
76 /* This is used to pass the current command timestamp down to
77 continuation routines. */
78 static struct mi_timestamp *current_command_ts;
80 static int do_timings = 0;
83 /* Few commands would like to know if options like --thread-group were
84 explicitly specified. This variable keeps the current parsed
85 command including all option, and make it possible. */
86 static struct mi_parse *current_context;
88 int running_result_record_printed = 1;
90 /* Flag indicating that the target has proceeded since the last
91 command was issued. */
94 extern void _initialize_mi_main (void);
95 static void mi_cmd_execute (struct mi_parse *parse);
97 static void mi_execute_cli_command (const char *cmd, int args_p,
99 static void mi_execute_async_cli_command (char *cli_command,
100 char **argv, int argc);
101 static int register_changed_p (int regnum, struct regcache *,
103 static void get_register (struct frame_info *, int regnum, int format);
105 /* Command implementations. FIXME: Is this libgdb? No. This is the MI
106 layer that calls libgdb. Any operation used in the below should be
109 static void timestamp (struct mi_timestamp *tv);
111 static void print_diff_now (struct mi_timestamp *start);
112 static void print_diff (struct mi_timestamp *start, struct mi_timestamp *end);
115 mi_cmd_gdb_exit (char *command, char **argv, int argc)
117 /* We have to print everything right here because we never return. */
119 fputs_unfiltered (current_token, raw_stdout);
120 fputs_unfiltered ("^exit\n", raw_stdout);
121 mi_out_put (current_uiout, raw_stdout);
122 gdb_flush (raw_stdout);
123 /* FIXME: The function called is not yet a formal libgdb function. */
124 quit_force (NULL, FROM_TTY);
128 mi_cmd_exec_next (char *command, char **argv, int argc)
130 /* FIXME: Should call a libgdb function, not a cli wrapper. */
131 if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
132 mi_execute_async_cli_command ("reverse-next", argv + 1, argc - 1);
134 mi_execute_async_cli_command ("next", argv, argc);
138 mi_cmd_exec_next_instruction (char *command, char **argv, int argc)
140 /* FIXME: Should call a libgdb function, not a cli wrapper. */
141 if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
142 mi_execute_async_cli_command ("reverse-nexti", argv + 1, argc - 1);
144 mi_execute_async_cli_command ("nexti", argv, argc);
148 mi_cmd_exec_step (char *command, char **argv, int argc)
150 /* FIXME: Should call a libgdb function, not a cli wrapper. */
151 if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
152 mi_execute_async_cli_command ("reverse-step", argv + 1, argc - 1);
154 mi_execute_async_cli_command ("step", argv, argc);
158 mi_cmd_exec_step_instruction (char *command, char **argv, int argc)
160 /* FIXME: Should call a libgdb function, not a cli wrapper. */
161 if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
162 mi_execute_async_cli_command ("reverse-stepi", argv + 1, argc - 1);
164 mi_execute_async_cli_command ("stepi", argv, argc);
168 mi_cmd_exec_finish (char *command, char **argv, int argc)
170 /* FIXME: Should call a libgdb function, not a cli wrapper. */
171 if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
172 mi_execute_async_cli_command ("reverse-finish", argv + 1, argc - 1);
174 mi_execute_async_cli_command ("finish", argv, argc);
178 mi_cmd_exec_return (char *command, char **argv, int argc)
180 /* This command doesn't really execute the target, it just pops the
181 specified number of frames. */
183 /* Call return_command with from_tty argument equal to 0 so as to
184 avoid being queried. */
185 return_command (*argv, 0);
187 /* Call return_command with from_tty argument equal to 0 so as to
188 avoid being queried. */
189 return_command (NULL, 0);
191 /* Because we have called return_command with from_tty = 0, we need
192 to print the frame here. */
193 print_stack_frame (get_selected_frame (NULL), 1, LOC_AND_ADDRESS);
197 mi_cmd_exec_jump (char *args, char **argv, int argc)
199 /* FIXME: Should call a libgdb function, not a cli wrapper. */
200 mi_execute_async_cli_command ("jump", argv, argc);
204 proceed_thread (struct thread_info *thread, int pid)
206 if (!is_stopped (thread->ptid))
209 if (pid != 0 && PIDGET (thread->ptid) != pid)
212 switch_to_thread (thread->ptid);
213 clear_proceed_status ();
214 proceed ((CORE_ADDR) -1, GDB_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.
232 Therefore, to resume all threads of the current inferior, or
233 all threads in all inferiors, we need to iterate over
236 See comment on infcmd.c:proceed_thread_callback for rationale. */
237 if (current_context->all || current_context->thread_group != -1)
240 struct cleanup *back_to = make_cleanup_restore_current_thread ();
242 if (!current_context->all)
245 = find_inferior_id (current_context->thread_group);
249 iterate_over_threads (proceed_thread_callback, &pid);
250 do_cleanups (back_to);
259 struct cleanup *back_to = make_cleanup_restore_integer (&sched_multi);
261 if (current_context->all)
268 /* In all-stop mode, -exec-continue traditionally resumed
269 either all threads, or one thread, depending on the
270 'scheduler-locking' variable. Let's continue to do the
274 do_cleanups (back_to);
279 exec_direction_forward (void *notused)
281 execution_direction = EXEC_FORWARD;
285 exec_reverse_continue (char **argv, int argc)
287 enum exec_direction_kind dir = execution_direction;
288 struct cleanup *old_chain;
290 if (dir == EXEC_REVERSE)
291 error (_("Already in reverse mode."));
293 if (!target_can_execute_reverse)
294 error (_("Target %s does not support this command."), target_shortname);
296 old_chain = make_cleanup (exec_direction_forward, NULL);
297 execution_direction = EXEC_REVERSE;
298 exec_continue (argv, argc);
299 do_cleanups (old_chain);
303 mi_cmd_exec_continue (char *command, char **argv, int argc)
305 if (argc > 0 && strcmp (argv[0], "--reverse") == 0)
306 exec_reverse_continue (argv + 1, argc - 1);
308 exec_continue (argv, argc);
312 interrupt_thread_callback (struct thread_info *thread, void *arg)
314 int pid = *(int *)arg;
316 if (!is_running (thread->ptid))
319 if (PIDGET (thread->ptid) != pid)
322 target_stop (thread->ptid);
326 /* Interrupt the execution of the target. Note how we must play
327 around with the token variables, in order to display the current
328 token in the result of the interrupt command, and the previous
329 execution token when the target finally stops. See comments in
333 mi_cmd_exec_interrupt (char *command, char **argv, int argc)
335 /* In all-stop mode, everything stops, so we don't need to try
336 anything specific. */
339 interrupt_target_1 (0);
343 if (current_context->all)
345 /* This will interrupt all threads in all inferiors. */
346 interrupt_target_1 (1);
348 else if (current_context->thread_group != -1)
350 struct inferior *inf = find_inferior_id (current_context->thread_group);
352 iterate_over_threads (interrupt_thread_callback, &inf->pid);
356 /* Interrupt just the current thread -- either explicitly
357 specified via --thread or whatever was current before
358 MI command was sent. */
359 interrupt_target_1 (0);
364 run_one_inferior (struct inferior *inf, void *arg)
368 if (inf->pid != ptid_get_pid (inferior_ptid))
370 struct thread_info *tp;
372 tp = any_thread_of_process (inf->pid);
374 error (_("Inferior has no threads."));
376 switch_to_thread (tp->ptid);
381 set_current_inferior (inf);
382 switch_to_thread (null_ptid);
383 set_current_program_space (inf->pspace);
385 mi_execute_cli_command ("run", target_can_async_p (),
386 target_can_async_p () ? "&" : NULL);
391 mi_cmd_exec_run (char *command, char **argv, int argc)
393 if (current_context->all)
395 struct cleanup *back_to = save_current_space_and_thread ();
397 iterate_over_inferiors (run_one_inferior, NULL);
398 do_cleanups (back_to);
402 mi_execute_cli_command ("run", target_can_async_p (),
403 target_can_async_p () ? "&" : NULL);
409 find_thread_of_process (struct thread_info *ti, void *p)
413 if (PIDGET (ti->ptid) == pid && !is_exited (ti->ptid))
420 mi_cmd_target_detach (char *command, char **argv, int argc)
422 if (argc != 0 && argc != 1)
423 error (_("Usage: -target-detach [pid | thread-group]"));
427 struct thread_info *tp;
431 /* First see if we are dealing with a thread-group id. */
434 struct inferior *inf;
435 int id = strtoul (argv[0] + 1, &end, 0);
438 error (_("Invalid syntax of thread-group id '%s'"), argv[0]);
440 inf = find_inferior_id (id);
442 error (_("Non-existent thread-group id '%d'"), id);
448 /* We must be dealing with a pid. */
449 pid = strtol (argv[0], &end, 10);
452 error (_("Invalid identifier '%s'"), argv[0]);
455 /* Pick any thread in the desired process. Current
456 target_detach detaches from the parent of inferior_ptid. */
457 tp = iterate_over_threads (find_thread_of_process, &pid);
459 error (_("Thread group is empty"));
461 switch_to_thread (tp->ptid);
464 detach_command (NULL, 0);
468 mi_cmd_thread_select (char *command, char **argv, int argc)
471 char *mi_error_message;
474 error (_("-thread-select: USAGE: threadnum."));
476 rc = gdb_thread_select (current_uiout, argv[0], &mi_error_message);
478 if (rc == GDB_RC_FAIL)
480 make_cleanup (xfree, mi_error_message);
481 error ("%s", mi_error_message);
486 mi_cmd_thread_list_ids (char *command, char **argv, int argc)
489 char *mi_error_message;
492 error (_("-thread-list-ids: No arguments required."));
494 rc = gdb_list_thread_ids (current_uiout, &mi_error_message);
496 if (rc == GDB_RC_FAIL)
498 make_cleanup (xfree, mi_error_message);
499 error ("%s", mi_error_message);
504 mi_cmd_thread_info (char *command, char **argv, int argc)
506 if (argc != 0 && argc != 1)
507 error (_("Invalid MI command"));
509 print_thread_info (current_uiout, argv[0], -1);
514 struct collect_cores_data
522 collect_cores (struct thread_info *ti, void *xdata)
524 struct collect_cores_data *data = xdata;
526 if (ptid_get_pid (ti->ptid) == data->pid)
528 int core = target_core_of_thread (ti->ptid);
531 VEC_safe_push (int, data->cores, core);
538 unique (int *b, int *e)
548 struct print_one_inferior_data
551 VEC (int) *inferiors;
555 print_one_inferior (struct inferior *inferior, void *xdata)
557 struct print_one_inferior_data *top_data = xdata;
558 struct ui_out *uiout = current_uiout;
560 if (VEC_empty (int, top_data->inferiors)
561 || bsearch (&(inferior->pid), VEC_address (int, top_data->inferiors),
562 VEC_length (int, top_data->inferiors), sizeof (int),
563 compare_positive_ints))
565 struct collect_cores_data data;
566 struct cleanup *back_to
567 = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
569 ui_out_field_fmt (uiout, "id", "i%d", inferior->num);
570 ui_out_field_string (uiout, "type", "process");
571 if (inferior->pid != 0)
572 ui_out_field_int (uiout, "pid", inferior->pid);
574 if (inferior->pspace->ebfd)
576 ui_out_field_string (uiout, "executable",
577 bfd_get_filename (inferior->pspace->ebfd));
581 if (inferior->pid != 0)
583 data.pid = inferior->pid;
584 iterate_over_threads (collect_cores, &data);
587 if (!VEC_empty (int, data.cores))
590 struct cleanup *back_to_2 =
591 make_cleanup_ui_out_list_begin_end (uiout, "cores");
593 qsort (VEC_address (int, data.cores),
594 VEC_length (int, data.cores), sizeof (int),
595 compare_positive_ints);
597 b = VEC_address (int, data.cores);
598 e = b + VEC_length (int, data.cores);
602 ui_out_field_int (uiout, NULL, *b);
604 do_cleanups (back_to_2);
607 if (top_data->recurse)
608 print_thread_info (uiout, NULL, inferior->pid);
610 do_cleanups (back_to);
616 /* Output a field named 'cores' with a list as the value. The
617 elements of the list are obtained by splitting 'cores' on
621 output_cores (struct ui_out *uiout, const char *field_name, const char *xcores)
623 struct cleanup *back_to = make_cleanup_ui_out_list_begin_end (uiout,
625 char *cores = xstrdup (xcores);
628 make_cleanup (xfree, cores);
630 for (p = strtok (p, ","); p; p = strtok (NULL, ","))
631 ui_out_field_string (uiout, NULL, p);
633 do_cleanups (back_to);
637 free_vector_of_ints (void *xvector)
639 VEC (int) **vector = xvector;
641 VEC_free (int, *vector);
645 do_nothing (splay_tree_key k)
650 free_vector_of_osdata_items (splay_tree_value xvalue)
652 VEC (osdata_item_s) *value = (VEC (osdata_item_s) *) xvalue;
654 /* We don't free the items itself, it will be done separately. */
655 VEC_free (osdata_item_s, value);
659 splay_tree_int_comparator (splay_tree_key xa, splay_tree_key xb)
668 free_splay_tree (void *xt)
671 splay_tree_delete (t);
675 list_available_thread_groups (VEC (int) *ids, int recurse)
678 struct osdata_item *item;
680 struct ui_out *uiout = current_uiout;
682 /* This keeps a map from integer (pid) to VEC (struct osdata_item *)*
683 The vector contains information about all threads for the given pid.
684 This is assigned an initial value to avoid "may be used uninitialized"
686 splay_tree tree = NULL;
688 /* get_osdata will throw if it cannot return data. */
689 data = get_osdata ("processes");
690 make_cleanup_osdata_free (data);
694 struct osdata *threads = get_osdata ("threads");
696 make_cleanup_osdata_free (threads);
697 tree = splay_tree_new (splay_tree_int_comparator,
699 free_vector_of_osdata_items);
700 make_cleanup (free_splay_tree, tree);
703 VEC_iterate (osdata_item_s, threads->items,
707 const char *pid = get_osdata_column (item, "pid");
708 int pid_i = strtoul (pid, NULL, 0);
709 VEC (osdata_item_s) *vec = 0;
711 splay_tree_node n = splay_tree_lookup (tree, pid_i);
714 VEC_safe_push (osdata_item_s, vec, item);
715 splay_tree_insert (tree, pid_i, (splay_tree_value)vec);
719 vec = (VEC (osdata_item_s) *) n->value;
720 VEC_safe_push (osdata_item_s, vec, item);
721 n->value = (splay_tree_value) vec;
726 make_cleanup_ui_out_list_begin_end (uiout, "groups");
729 VEC_iterate (osdata_item_s, data->items,
733 struct cleanup *back_to;
735 const char *pid = get_osdata_column (item, "pid");
736 const char *cmd = get_osdata_column (item, "command");
737 const char *user = get_osdata_column (item, "user");
738 const char *cores = get_osdata_column (item, "cores");
740 int pid_i = strtoul (pid, NULL, 0);
742 /* At present, the target will return all available processes
743 and if information about specific ones was required, we filter
744 undesired processes here. */
745 if (ids && bsearch (&pid_i, VEC_address (int, ids),
746 VEC_length (int, ids),
747 sizeof (int), compare_positive_ints) == NULL)
751 back_to = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
753 ui_out_field_fmt (uiout, "id", "%s", pid);
754 ui_out_field_string (uiout, "type", "process");
756 ui_out_field_string (uiout, "description", cmd);
758 ui_out_field_string (uiout, "user", user);
760 output_cores (uiout, "cores", cores);
764 splay_tree_node n = splay_tree_lookup (tree, pid_i);
767 VEC (osdata_item_s) *children = (VEC (osdata_item_s) *) n->value;
768 struct osdata_item *child;
771 make_cleanup_ui_out_list_begin_end (uiout, "threads");
774 VEC_iterate (osdata_item_s, children, ix_child, child);
777 struct cleanup *back_to_2 =
778 make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
779 const char *tid = get_osdata_column (child, "tid");
780 const char *tcore = get_osdata_column (child, "core");
782 ui_out_field_string (uiout, "id", tid);
784 ui_out_field_string (uiout, "core", tcore);
786 do_cleanups (back_to_2);
791 do_cleanups (back_to);
796 mi_cmd_list_thread_groups (char *command, char **argv, int argc)
798 struct ui_out *uiout = current_uiout;
799 struct cleanup *back_to;
806 AVAILABLE_OPT, RECURSE_OPT
808 static const struct mi_opt opts[] =
810 {"-available", AVAILABLE_OPT, 0},
811 {"-recurse", RECURSE_OPT, 1},
820 int opt = mi_getopt ("-list-thread-groups", argc, argv, opts,
825 switch ((enum opt) opt)
831 if (strcmp (oarg, "0") == 0)
833 else if (strcmp (oarg, "1") == 0)
836 error (_("only '0' and '1' are valid values "
837 "for the '--recurse' option"));
842 for (; oind < argc; ++oind)
847 if (*(argv[oind]) != 'i')
848 error (_("invalid syntax of group id '%s'"), argv[oind]);
850 inf = strtoul (argv[oind] + 1, &end, 0);
853 error (_("invalid syntax of group id '%s'"), argv[oind]);
854 VEC_safe_push (int, ids, inf);
856 if (VEC_length (int, ids) > 1)
857 qsort (VEC_address (int, ids),
858 VEC_length (int, ids),
859 sizeof (int), compare_positive_ints);
861 back_to = make_cleanup (free_vector_of_ints, &ids);
865 list_available_thread_groups (ids, recurse);
867 else if (VEC_length (int, ids) == 1)
869 /* Local thread groups, single id. */
870 int id = *VEC_address (int, ids);
871 struct inferior *inf = find_inferior_id (id);
874 error (_("Non-existent thread group id '%d'"), id);
876 print_thread_info (uiout, NULL, inf->pid);
880 struct print_one_inferior_data data;
882 data.recurse = recurse;
883 data.inferiors = ids;
885 /* Local thread groups. Either no explicit ids -- and we
886 print everything, or several explicit ids. In both cases,
887 we print more than one group, and have to use 'groups'
888 as the top-level element. */
889 make_cleanup_ui_out_list_begin_end (uiout, "groups");
890 update_thread_list ();
891 iterate_over_inferiors (print_one_inferior, &data);
894 do_cleanups (back_to);
898 mi_cmd_data_list_register_names (char *command, char **argv, int argc)
900 struct gdbarch *gdbarch;
901 struct ui_out *uiout = current_uiout;
904 struct cleanup *cleanup;
906 /* Note that the test for a valid register must include checking the
907 gdbarch_register_name because gdbarch_num_regs may be allocated
908 for the union of the register sets within a family of related
909 processors. In this case, some entries of gdbarch_register_name
910 will change depending upon the particular processor being
913 gdbarch = get_current_arch ();
914 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
916 cleanup = make_cleanup_ui_out_list_begin_end (uiout, "register-names");
918 if (argc == 0) /* No args, just do all the regs. */
924 if (gdbarch_register_name (gdbarch, regnum) == NULL
925 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
926 ui_out_field_string (uiout, NULL, "");
928 ui_out_field_string (uiout, NULL,
929 gdbarch_register_name (gdbarch, regnum));
933 /* Else, list of register #s, just do listed regs. */
934 for (i = 0; i < argc; i++)
936 regnum = atoi (argv[i]);
937 if (regnum < 0 || regnum >= numregs)
938 error (_("bad register number"));
940 if (gdbarch_register_name (gdbarch, regnum) == NULL
941 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
942 ui_out_field_string (uiout, NULL, "");
944 ui_out_field_string (uiout, NULL,
945 gdbarch_register_name (gdbarch, regnum));
947 do_cleanups (cleanup);
951 mi_cmd_data_list_changed_registers (char *command, char **argv, int argc)
953 static struct regcache *this_regs = NULL;
954 struct ui_out *uiout = current_uiout;
955 struct regcache *prev_regs;
956 struct gdbarch *gdbarch;
957 int regnum, numregs, changed;
959 struct cleanup *cleanup;
961 /* The last time we visited this function, the current frame's
962 register contents were saved in THIS_REGS. Move THIS_REGS over
963 to PREV_REGS, and refresh THIS_REGS with the now-current register
966 prev_regs = this_regs;
967 this_regs = frame_save_as_regcache (get_selected_frame (NULL));
968 cleanup = make_cleanup_regcache_xfree (prev_regs);
970 /* Note that the test for a valid register must include checking the
971 gdbarch_register_name because gdbarch_num_regs may be allocated
972 for the union of the register sets within a family of related
973 processors. In this case, some entries of gdbarch_register_name
974 will change depending upon the particular processor being
977 gdbarch = get_regcache_arch (this_regs);
978 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
980 make_cleanup_ui_out_list_begin_end (uiout, "changed-registers");
984 /* No args, just do all the regs. */
989 if (gdbarch_register_name (gdbarch, regnum) == NULL
990 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
992 changed = register_changed_p (regnum, prev_regs, this_regs);
994 error (_("-data-list-changed-registers: "
995 "Unable to read register contents."));
997 ui_out_field_int (uiout, NULL, regnum);
1001 /* Else, list of register #s, just do listed regs. */
1002 for (i = 0; i < argc; i++)
1004 regnum = atoi (argv[i]);
1008 && gdbarch_register_name (gdbarch, regnum) != NULL
1009 && *gdbarch_register_name (gdbarch, regnum) != '\000')
1011 changed = register_changed_p (regnum, prev_regs, this_regs);
1013 error (_("-data-list-changed-registers: "
1014 "Unable to read register contents."));
1016 ui_out_field_int (uiout, NULL, regnum);
1019 error (_("bad register number"));
1021 do_cleanups (cleanup);
1025 register_changed_p (int regnum, struct regcache *prev_regs,
1026 struct regcache *this_regs)
1028 struct gdbarch *gdbarch = get_regcache_arch (this_regs);
1029 gdb_byte prev_buffer[MAX_REGISTER_SIZE];
1030 gdb_byte this_buffer[MAX_REGISTER_SIZE];
1031 enum register_status prev_status;
1032 enum register_status this_status;
1034 /* First time through or after gdbarch change consider all registers
1036 if (!prev_regs || get_regcache_arch (prev_regs) != gdbarch)
1039 /* Get register contents and compare. */
1040 prev_status = regcache_cooked_read (prev_regs, regnum, prev_buffer);
1041 this_status = regcache_cooked_read (this_regs, regnum, this_buffer);
1043 if (this_status != prev_status)
1045 else if (this_status == REG_VALID)
1046 return memcmp (prev_buffer, this_buffer,
1047 register_size (gdbarch, regnum)) != 0;
1052 /* Return a list of register number and value pairs. The valid
1053 arguments expected are: a letter indicating the format in which to
1054 display the registers contents. This can be one of: x
1055 (hexadecimal), d (decimal), N (natural), t (binary), o (octal), r
1056 (raw). After the format argument there can be a sequence of
1057 numbers, indicating which registers to fetch the content of. If
1058 the format is the only argument, a list of all the registers with
1059 their values is returned. */
1062 mi_cmd_data_list_register_values (char *command, char **argv, int argc)
1064 struct ui_out *uiout = current_uiout;
1065 struct frame_info *frame;
1066 struct gdbarch *gdbarch;
1067 int regnum, numregs, format;
1069 struct cleanup *list_cleanup, *tuple_cleanup;
1071 /* Note that the test for a valid register must include checking the
1072 gdbarch_register_name because gdbarch_num_regs may be allocated
1073 for the union of the register sets within a family of related
1074 processors. In this case, some entries of gdbarch_register_name
1075 will change depending upon the particular processor being
1079 error (_("-data-list-register-values: Usage: "
1080 "-data-list-register-values <format> [<regnum1>...<regnumN>]"));
1082 format = (int) argv[0][0];
1084 frame = get_selected_frame (NULL);
1085 gdbarch = get_frame_arch (frame);
1086 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
1088 list_cleanup = make_cleanup_ui_out_list_begin_end (uiout, "register-values");
1092 /* No args, beside the format: do all the regs. */
1097 if (gdbarch_register_name (gdbarch, regnum) == NULL
1098 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
1100 tuple_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1101 ui_out_field_int (uiout, "number", regnum);
1102 get_register (frame, regnum, format);
1103 do_cleanups (tuple_cleanup);
1107 /* Else, list of register #s, just do listed regs. */
1108 for (i = 1; i < argc; i++)
1110 regnum = atoi (argv[i]);
1114 && gdbarch_register_name (gdbarch, regnum) != NULL
1115 && *gdbarch_register_name (gdbarch, regnum) != '\000')
1117 tuple_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1118 ui_out_field_int (uiout, "number", regnum);
1119 get_register (frame, regnum, format);
1120 do_cleanups (tuple_cleanup);
1123 error (_("bad register number"));
1125 do_cleanups (list_cleanup);
1128 /* Output one register's contents in the desired format. */
1131 get_register (struct frame_info *frame, int regnum, int format)
1133 struct gdbarch *gdbarch = get_frame_arch (frame);
1134 struct ui_out *uiout = current_uiout;
1140 val = get_frame_register_value (frame, regnum);
1142 if (value_optimized_out (val))
1143 error (_("Optimized out"));
1148 char *ptr, buf[1024];
1149 const gdb_byte *valaddr = value_contents_for_printing (val);
1153 for (j = 0; j < register_size (gdbarch, regnum); j++)
1155 int idx = gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG ?
1156 j : register_size (gdbarch, regnum) - 1 - j;
1158 sprintf (ptr, "%02x", (unsigned char) valaddr[idx]);
1161 ui_out_field_string (uiout, "value", buf);
1165 struct value_print_options opts;
1166 struct ui_file *stb;
1167 struct cleanup *old_chain;
1169 stb = mem_fileopen ();
1170 old_chain = make_cleanup_ui_file_delete (stb);
1172 get_formatted_print_options (&opts, format);
1174 val_print (value_type (val),
1175 value_contents_for_printing (val),
1176 value_embedded_offset (val), 0,
1177 stb, 0, val, &opts, current_language);
1178 ui_out_field_stream (uiout, "value", stb);
1179 do_cleanups (old_chain);
1183 /* Write given values into registers. The registers and values are
1184 given as pairs. The corresponding MI command is
1185 -data-write-register-values <format>
1186 [<regnum1> <value1>...<regnumN> <valueN>] */
1188 mi_cmd_data_write_register_values (char *command, char **argv, int argc)
1190 struct regcache *regcache;
1191 struct gdbarch *gdbarch;
1194 /* Note that the test for a valid register must include checking the
1195 gdbarch_register_name because gdbarch_num_regs may be allocated
1196 for the union of the register sets within a family of related
1197 processors. In this case, some entries of gdbarch_register_name
1198 will change depending upon the particular processor being
1201 regcache = get_current_regcache ();
1202 gdbarch = get_regcache_arch (regcache);
1203 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
1206 error (_("-data-write-register-values: Usage: -data-write-register-"
1207 "values <format> [<regnum1> <value1>...<regnumN> <valueN>]"));
1209 if (!target_has_registers)
1210 error (_("-data-write-register-values: No registers."));
1213 error (_("-data-write-register-values: No regs and values specified."));
1216 error (_("-data-write-register-values: "
1217 "Regs and vals are not in pairs."));
1219 for (i = 1; i < argc; i = i + 2)
1221 int regnum = atoi (argv[i]);
1223 if (regnum >= 0 && regnum < numregs
1224 && gdbarch_register_name (gdbarch, regnum)
1225 && *gdbarch_register_name (gdbarch, regnum))
1229 /* Get the value as a number. */
1230 value = parse_and_eval_address (argv[i + 1]);
1232 /* Write it down. */
1233 regcache_cooked_write_signed (regcache, regnum, value);
1236 error (_("bad register number"));
1240 /* Evaluate the value of the argument. The argument is an
1241 expression. If the expression contains spaces it needs to be
1242 included in double quotes. */
1245 mi_cmd_data_evaluate_expression (char *command, char **argv, int argc)
1247 struct expression *expr;
1248 struct cleanup *old_chain;
1250 struct ui_file *stb;
1251 struct value_print_options opts;
1252 struct ui_out *uiout = current_uiout;
1254 stb = mem_fileopen ();
1255 old_chain = make_cleanup_ui_file_delete (stb);
1258 error (_("-data-evaluate-expression: "
1259 "Usage: -data-evaluate-expression expression"));
1261 expr = parse_expression (argv[0]);
1263 make_cleanup (free_current_contents, &expr);
1265 val = evaluate_expression (expr);
1267 /* Print the result of the expression evaluation. */
1268 get_user_print_options (&opts);
1270 common_val_print (val, stb, 0, &opts, current_language);
1272 ui_out_field_stream (uiout, "value", stb);
1274 do_cleanups (old_chain);
1277 /* This is the -data-read-memory command.
1279 ADDR: start address of data to be dumped.
1280 WORD-FORMAT: a char indicating format for the ``word''. See
1282 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
1283 NR_ROW: Number of rows.
1284 NR_COL: The number of colums (words per row).
1285 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
1286 ASCHAR for unprintable characters.
1288 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
1289 displayes them. Returns:
1291 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
1294 The number of bytes read is SIZE*ROW*COL. */
1297 mi_cmd_data_read_memory (char *command, char **argv, int argc)
1299 struct gdbarch *gdbarch = get_current_arch ();
1300 struct ui_out *uiout = current_uiout;
1301 struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
1303 long total_bytes, nr_cols, nr_rows;
1305 struct type *word_type;
1318 static const struct mi_opt opts[] =
1320 {"o", OFFSET_OPT, 1},
1326 int opt = mi_getopt ("-data-read-memory", argc, argv, opts,
1331 switch ((enum opt) opt)
1334 offset = atol (oarg);
1341 if (argc < 5 || argc > 6)
1342 error (_("-data-read-memory: Usage: "
1343 "ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR]."));
1345 /* Extract all the arguments. */
1347 /* Start address of the memory dump. */
1348 addr = parse_and_eval_address (argv[0]) + offset;
1349 /* The format character to use when displaying a memory word. See
1350 the ``x'' command. */
1351 word_format = argv[1][0];
1352 /* The size of the memory word. */
1353 word_size = atol (argv[2]);
1357 word_type = builtin_type (gdbarch)->builtin_int8;
1361 word_type = builtin_type (gdbarch)->builtin_int16;
1365 word_type = builtin_type (gdbarch)->builtin_int32;
1369 word_type = builtin_type (gdbarch)->builtin_int64;
1373 word_type = builtin_type (gdbarch)->builtin_int8;
1376 /* The number of rows. */
1377 nr_rows = atol (argv[3]);
1379 error (_("-data-read-memory: invalid number of rows."));
1381 /* Number of bytes per row. */
1382 nr_cols = atol (argv[4]);
1384 error (_("-data-read-memory: invalid number of columns."));
1386 /* The un-printable character when printing ascii. */
1392 /* Create a buffer and read it in. */
1393 total_bytes = word_size * nr_rows * nr_cols;
1394 mbuf = xcalloc (total_bytes, 1);
1395 make_cleanup (xfree, mbuf);
1397 /* Dispatch memory reads to the topmost target, not the flattened
1399 nr_bytes = target_read (current_target.beneath,
1400 TARGET_OBJECT_MEMORY, NULL, mbuf,
1403 error (_("Unable to read memory."));
1405 /* Output the header information. */
1406 ui_out_field_core_addr (uiout, "addr", gdbarch, addr);
1407 ui_out_field_int (uiout, "nr-bytes", nr_bytes);
1408 ui_out_field_int (uiout, "total-bytes", total_bytes);
1409 ui_out_field_core_addr (uiout, "next-row",
1410 gdbarch, addr + word_size * nr_cols);
1411 ui_out_field_core_addr (uiout, "prev-row",
1412 gdbarch, addr - word_size * nr_cols);
1413 ui_out_field_core_addr (uiout, "next-page", gdbarch, addr + total_bytes);
1414 ui_out_field_core_addr (uiout, "prev-page", gdbarch, addr - total_bytes);
1416 /* Build the result as a two dimentional table. */
1418 struct ui_file *stream;
1419 struct cleanup *cleanup_stream;
1423 stream = mem_fileopen ();
1424 cleanup_stream = make_cleanup_ui_file_delete (stream);
1426 make_cleanup_ui_out_list_begin_end (uiout, "memory");
1427 for (row = 0, row_byte = 0;
1429 row++, row_byte += nr_cols * word_size)
1433 struct cleanup *cleanup_tuple;
1434 struct cleanup *cleanup_list_data;
1435 struct value_print_options opts;
1437 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1438 ui_out_field_core_addr (uiout, "addr", gdbarch, addr + row_byte);
1439 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr +
1441 cleanup_list_data = make_cleanup_ui_out_list_begin_end (uiout, "data");
1442 get_formatted_print_options (&opts, word_format);
1443 for (col = 0, col_byte = row_byte;
1445 col++, col_byte += word_size)
1447 if (col_byte + word_size > nr_bytes)
1449 ui_out_field_string (uiout, NULL, "N/A");
1453 ui_file_rewind (stream);
1454 print_scalar_formatted (mbuf + col_byte, word_type, &opts,
1455 word_asize, stream);
1456 ui_out_field_stream (uiout, NULL, stream);
1459 do_cleanups (cleanup_list_data);
1464 ui_file_rewind (stream);
1465 for (byte = row_byte;
1466 byte < row_byte + word_size * nr_cols; byte++)
1468 if (byte >= nr_bytes)
1469 fputc_unfiltered ('X', stream);
1470 else if (mbuf[byte] < 32 || mbuf[byte] > 126)
1471 fputc_unfiltered (aschar, stream);
1473 fputc_unfiltered (mbuf[byte], stream);
1475 ui_out_field_stream (uiout, "ascii", stream);
1477 do_cleanups (cleanup_tuple);
1479 do_cleanups (cleanup_stream);
1481 do_cleanups (cleanups);
1485 mi_cmd_data_read_memory_bytes (char *command, char **argv, int argc)
1487 struct gdbarch *gdbarch = get_current_arch ();
1488 struct ui_out *uiout = current_uiout;
1489 struct cleanup *cleanups;
1492 memory_read_result_s *read_result;
1494 VEC(memory_read_result_s) *result;
1502 static const struct mi_opt opts[] =
1504 {"o", OFFSET_OPT, 1},
1510 int opt = mi_getopt ("-data-read-memory-bytes", argc, argv, opts,
1514 switch ((enum opt) opt)
1517 offset = atol (oarg);
1525 error (_("Usage: [ -o OFFSET ] ADDR LENGTH."));
1527 addr = parse_and_eval_address (argv[0]) + offset;
1528 length = atol (argv[1]);
1530 result = read_memory_robust (current_target.beneath, addr, length);
1532 cleanups = make_cleanup (free_memory_read_result_vector, result);
1534 if (VEC_length (memory_read_result_s, result) == 0)
1535 error (_("Unable to read memory."));
1537 make_cleanup_ui_out_list_begin_end (uiout, "memory");
1539 VEC_iterate (memory_read_result_s, result, ix, read_result);
1542 struct cleanup *t = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1546 ui_out_field_core_addr (uiout, "begin", gdbarch, read_result->begin);
1547 ui_out_field_core_addr (uiout, "offset", gdbarch, read_result->begin
1549 ui_out_field_core_addr (uiout, "end", gdbarch, read_result->end);
1551 data = xmalloc ((read_result->end - read_result->begin) * 2 + 1);
1553 for (i = 0, p = data;
1554 i < (read_result->end - read_result->begin);
1557 sprintf (p, "%02x", read_result->data[i]);
1559 ui_out_field_string (uiout, "contents", data);
1563 do_cleanups (cleanups);
1566 /* Implementation of the -data-write_memory command.
1568 COLUMN_OFFSET: optional argument. Must be preceded by '-o'. The
1569 offset from the beginning of the memory grid row where the cell to
1571 ADDR: start address of the row in the memory grid where the memory
1572 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
1573 the location to write to.
1574 FORMAT: a char indicating format for the ``word''. See
1576 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
1577 VALUE: value to be written into the memory address.
1579 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1584 mi_cmd_data_write_memory (char *command, char **argv, int argc)
1586 struct gdbarch *gdbarch = get_current_arch ();
1587 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1590 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1591 enough when using a compiler other than GCC. */
1594 struct cleanup *old_chain;
1602 static const struct mi_opt opts[] =
1604 {"o", OFFSET_OPT, 1},
1610 int opt = mi_getopt ("-data-write-memory", argc, argv, opts,
1615 switch ((enum opt) opt)
1618 offset = atol (oarg);
1626 error (_("-data-write-memory: Usage: "
1627 "[-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE."));
1629 /* Extract all the arguments. */
1630 /* Start address of the memory dump. */
1631 addr = parse_and_eval_address (argv[0]);
1632 /* The size of the memory word. */
1633 word_size = atol (argv[2]);
1635 /* Calculate the real address of the write destination. */
1636 addr += (offset * word_size);
1638 /* Get the value as a number. */
1639 value = parse_and_eval_address (argv[3]);
1640 /* Get the value into an array. */
1641 buffer = xmalloc (word_size);
1642 old_chain = make_cleanup (xfree, buffer);
1643 store_signed_integer (buffer, word_size, byte_order, value);
1644 /* Write it down to memory. */
1645 write_memory_with_notification (addr, buffer, word_size);
1646 /* Free the buffer. */
1647 do_cleanups (old_chain);
1650 /* Implementation of the -data-write-memory-bytes command.
1653 DATA: string of bytes to write at that address
1654 COUNT: number of bytes to be filled (decimal integer). */
1657 mi_cmd_data_write_memory_bytes (char *command, char **argv, int argc)
1663 size_t len, i, steps, remainder;
1665 struct cleanup *back_to;
1667 if (argc != 2 && argc != 3)
1668 error (_("Usage: ADDR DATA [COUNT]."));
1670 addr = parse_and_eval_address (argv[0]);
1672 if (strlen (cdata) % 2)
1673 error (_("Hex-encoded '%s' must have an even number of characters."),
1676 len = strlen (cdata)/2;
1678 count = strtoul (argv[2], NULL, 10);
1682 databuf = xmalloc (len * sizeof (gdb_byte));
1683 back_to = make_cleanup (xfree, databuf);
1685 for (i = 0; i < len; ++i)
1688 if (sscanf (cdata + i * 2, "%02x", &x) != 1)
1689 error (_("Invalid argument"));
1690 databuf[i] = (gdb_byte) x;
1695 /* Pattern is made of less bytes than count:
1696 repeat pattern to fill memory. */
1697 data = xmalloc (count);
1698 make_cleanup (xfree, data);
1700 steps = count / len;
1701 remainder = count % len;
1702 for (j = 0; j < steps; j++)
1703 memcpy (data + j * len, databuf, len);
1706 memcpy (data + steps * len, databuf, remainder);
1710 /* Pattern is longer than or equal to count:
1711 just copy len bytes. */
1715 write_memory_with_notification (addr, data, count);
1717 do_cleanups (back_to);
1721 mi_cmd_enable_timings (char *command, char **argv, int argc)
1727 if (strcmp (argv[0], "yes") == 0)
1729 else if (strcmp (argv[0], "no") == 0)
1740 error (_("-enable-timings: Usage: %s {yes|no}"), command);
1744 mi_cmd_list_features (char *command, char **argv, int argc)
1748 struct cleanup *cleanup = NULL;
1749 struct ui_out *uiout = current_uiout;
1751 cleanup = make_cleanup_ui_out_list_begin_end (uiout, "features");
1752 ui_out_field_string (uiout, NULL, "frozen-varobjs");
1753 ui_out_field_string (uiout, NULL, "pending-breakpoints");
1754 ui_out_field_string (uiout, NULL, "thread-info");
1755 ui_out_field_string (uiout, NULL, "data-read-memory-bytes");
1756 ui_out_field_string (uiout, NULL, "breakpoint-notifications");
1757 ui_out_field_string (uiout, NULL, "ada-task-info");
1760 ui_out_field_string (uiout, NULL, "python");
1763 do_cleanups (cleanup);
1767 error (_("-list-features should be passed no arguments"));
1771 mi_cmd_list_target_features (char *command, char **argv, int argc)
1775 struct cleanup *cleanup = NULL;
1776 struct ui_out *uiout = current_uiout;
1778 cleanup = make_cleanup_ui_out_list_begin_end (uiout, "features");
1779 if (target_can_async_p ())
1780 ui_out_field_string (uiout, NULL, "async");
1781 if (target_can_execute_reverse)
1782 ui_out_field_string (uiout, NULL, "reverse");
1784 do_cleanups (cleanup);
1788 error (_("-list-target-features should be passed no arguments"));
1792 mi_cmd_add_inferior (char *command, char **argv, int argc)
1794 struct inferior *inf;
1797 error (_("-add-inferior should be passed no arguments"));
1799 inf = add_inferior_with_spaces ();
1801 ui_out_field_fmt (current_uiout, "inferior", "i%d", inf->num);
1804 /* Callback used to find the first inferior other than the current
1808 get_other_inferior (struct inferior *inf, void *arg)
1810 if (inf == current_inferior ())
1817 mi_cmd_remove_inferior (char *command, char **argv, int argc)
1820 struct inferior *inf;
1823 error (_("-remove-inferior should be passed a single argument"));
1825 if (sscanf (argv[0], "i%d", &id) != 1)
1826 error (_("the thread group id is syntactically invalid"));
1828 inf = find_inferior_id (id);
1830 error (_("the specified thread group does not exist"));
1833 error (_("cannot remove an active inferior"));
1835 if (inf == current_inferior ())
1837 struct thread_info *tp = 0;
1838 struct inferior *new_inferior
1839 = iterate_over_inferiors (get_other_inferior, NULL);
1841 if (new_inferior == NULL)
1842 error (_("Cannot remove last inferior"));
1844 set_current_inferior (new_inferior);
1845 if (new_inferior->pid != 0)
1846 tp = any_thread_of_process (new_inferior->pid);
1847 switch_to_thread (tp ? tp->ptid : null_ptid);
1848 set_current_program_space (new_inferior->pspace);
1851 delete_inferior_1 (inf, 1 /* silent */);
1856 /* Execute a command within a safe environment.
1857 Return <0 for error; >=0 for ok.
1859 args->action will tell mi_execute_command what action
1860 to perfrom after the given command has executed (display/suppress
1861 prompt, display error). */
1864 captured_mi_execute_command (struct ui_out *uiout, struct mi_parse *context)
1866 struct cleanup *cleanup;
1869 current_command_ts = context->cmd_start;
1871 current_token = xstrdup (context->token);
1872 cleanup = make_cleanup (free_current_contents, ¤t_token);
1874 running_result_record_printed = 0;
1876 switch (context->op)
1879 /* A MI command was read from the input stream. */
1881 /* FIXME: gdb_???? */
1882 fprintf_unfiltered (raw_stdout, " token=`%s' command=`%s' args=`%s'\n",
1883 context->token, context->command, context->args);
1885 mi_cmd_execute (context);
1887 /* Print the result if there were no errors.
1889 Remember that on the way out of executing a command, you have
1890 to directly use the mi_interp's uiout, since the command
1891 could have reset the interpreter, in which case the current
1892 uiout will most likely crash in the mi_out_* routines. */
1893 if (!running_result_record_printed)
1895 fputs_unfiltered (context->token, raw_stdout);
1896 /* There's no particularly good reason why target-connect results
1897 in not ^done. Should kill ^connected for MI3. */
1898 fputs_unfiltered (strcmp (context->command, "target-select") == 0
1899 ? "^connected" : "^done", raw_stdout);
1900 mi_out_put (uiout, raw_stdout);
1901 mi_out_rewind (uiout);
1902 mi_print_timing_maybe ();
1903 fputs_unfiltered ("\n", raw_stdout);
1906 /* The command does not want anything to be printed. In that
1907 case, the command probably should not have written anything
1908 to uiout, but in case it has written something, discard it. */
1909 mi_out_rewind (uiout);
1916 /* A CLI command was read from the input stream. */
1917 /* This "feature" will be removed as soon as we have a
1918 complete set of mi commands. */
1919 /* Echo the command on the console. */
1920 fprintf_unfiltered (gdb_stdlog, "%s\n", context->command);
1921 /* Call the "console" interpreter. */
1922 argv[0] = "console";
1923 argv[1] = context->command;
1924 mi_cmd_interpreter_exec ("-interpreter-exec", argv, 2);
1926 /* If we changed interpreters, DON'T print out anything. */
1927 if (current_interp_named_p (INTERP_MI)
1928 || current_interp_named_p (INTERP_MI1)
1929 || current_interp_named_p (INTERP_MI2)
1930 || current_interp_named_p (INTERP_MI3))
1932 if (!running_result_record_printed)
1934 fputs_unfiltered (context->token, raw_stdout);
1935 fputs_unfiltered ("^done", raw_stdout);
1936 mi_out_put (uiout, raw_stdout);
1937 mi_out_rewind (uiout);
1938 mi_print_timing_maybe ();
1939 fputs_unfiltered ("\n", raw_stdout);
1942 mi_out_rewind (uiout);
1948 do_cleanups (cleanup);
1951 /* Print a gdb exception to the MI output stream. */
1954 mi_print_exception (const char *token, struct gdb_exception exception)
1956 fputs_unfiltered (token, raw_stdout);
1957 fputs_unfiltered ("^error,msg=\"", raw_stdout);
1958 if (exception.message == NULL)
1959 fputs_unfiltered ("unknown error", raw_stdout);
1961 fputstr_unfiltered (exception.message, '"', raw_stdout);
1962 fputs_unfiltered ("\"\n", raw_stdout);
1966 mi_execute_command (const char *cmd, int from_tty)
1969 struct mi_parse *command = NULL;
1970 volatile struct gdb_exception exception;
1972 /* This is to handle EOF (^D). We just quit gdb. */
1973 /* FIXME: we should call some API function here. */
1975 quit_force (NULL, from_tty);
1977 target_log_command (cmd);
1979 TRY_CATCH (exception, RETURN_MASK_ALL)
1981 command = mi_parse (cmd, &token);
1983 if (exception.reason < 0)
1985 mi_print_exception (token, exception);
1990 volatile struct gdb_exception result;
1991 ptid_t previous_ptid = inferior_ptid;
1993 command->token = token;
1997 command->cmd_start = (struct mi_timestamp *)
1998 xmalloc (sizeof (struct mi_timestamp));
1999 timestamp (command->cmd_start);
2002 TRY_CATCH (result, RETURN_MASK_ALL)
2004 captured_mi_execute_command (current_uiout, command);
2006 if (result.reason < 0)
2008 /* The command execution failed and error() was called
2010 mi_print_exception (command->token, result);
2011 mi_out_rewind (current_uiout);
2014 bpstat_do_actions ();
2016 if (/* The notifications are only output when the top-level
2017 interpreter (specified on the command line) is MI. */
2018 ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ()))
2019 /* Don't try report anything if there are no threads --
2020 the program is dead. */
2021 && thread_count () != 0
2022 /* -thread-select explicitly changes thread. If frontend uses that
2023 internally, we don't want to emit =thread-selected, since
2024 =thread-selected is supposed to indicate user's intentions. */
2025 && strcmp (command->command, "thread-select") != 0)
2027 struct mi_interp *mi = top_level_interpreter_data ();
2028 int report_change = 0;
2030 if (command->thread == -1)
2032 report_change = (!ptid_equal (previous_ptid, null_ptid)
2033 && !ptid_equal (inferior_ptid, previous_ptid)
2034 && !ptid_equal (inferior_ptid, null_ptid));
2036 else if (!ptid_equal (inferior_ptid, null_ptid))
2038 struct thread_info *ti = inferior_thread ();
2040 report_change = (ti->num != command->thread);
2045 struct thread_info *ti = inferior_thread ();
2047 target_terminal_ours ();
2048 fprintf_unfiltered (mi->event_channel,
2049 "thread-selected,id=\"%d\"",
2051 gdb_flush (mi->event_channel);
2055 mi_parse_free (command);
2060 mi_cmd_execute (struct mi_parse *parse)
2062 struct cleanup *cleanup;
2064 cleanup = prepare_execute_command ();
2066 if (parse->all && parse->thread_group != -1)
2067 error (_("Cannot specify --thread-group together with --all"));
2069 if (parse->all && parse->thread != -1)
2070 error (_("Cannot specify --thread together with --all"));
2072 if (parse->thread_group != -1 && parse->thread != -1)
2073 error (_("Cannot specify --thread together with --thread-group"));
2075 if (parse->frame != -1 && parse->thread == -1)
2076 error (_("Cannot specify --frame without --thread"));
2078 if (parse->thread_group != -1)
2080 struct inferior *inf = find_inferior_id (parse->thread_group);
2081 struct thread_info *tp = 0;
2084 error (_("Invalid thread group for the --thread-group option"));
2086 set_current_inferior (inf);
2087 /* This behaviour means that if --thread-group option identifies
2088 an inferior with multiple threads, then a random one will be
2089 picked. This is not a problem -- frontend should always
2090 provide --thread if it wishes to operate on a specific
2093 tp = any_live_thread_of_process (inf->pid);
2094 switch_to_thread (tp ? tp->ptid : null_ptid);
2095 set_current_program_space (inf->pspace);
2098 if (parse->thread != -1)
2100 struct thread_info *tp = find_thread_id (parse->thread);
2103 error (_("Invalid thread id: %d"), parse->thread);
2105 if (is_exited (tp->ptid))
2106 error (_("Thread id: %d has terminated"), parse->thread);
2108 switch_to_thread (tp->ptid);
2111 if (parse->frame != -1)
2113 struct frame_info *fid;
2114 int frame = parse->frame;
2116 fid = find_relative_frame (get_current_frame (), &frame);
2118 /* find_relative_frame was successful */
2121 error (_("Invalid frame id: %d"), frame);
2124 current_context = parse;
2126 if (parse->cmd->suppress_notification != NULL)
2128 make_cleanup_restore_integer (parse->cmd->suppress_notification);
2129 *parse->cmd->suppress_notification = 1;
2132 if (parse->cmd->argv_func != NULL)
2134 parse->cmd->argv_func (parse->command, parse->argv, parse->argc);
2136 else if (parse->cmd->cli.cmd != 0)
2138 /* FIXME: DELETE THIS. */
2139 /* The operation is still implemented by a cli command. */
2140 /* Must be a synchronous one. */
2141 mi_execute_cli_command (parse->cmd->cli.cmd, parse->cmd->cli.args_p,
2146 /* FIXME: DELETE THIS. */
2147 struct ui_file *stb;
2149 stb = mem_fileopen ();
2151 fputs_unfiltered ("Undefined mi command: ", stb);
2152 fputstr_unfiltered (parse->command, '"', stb);
2153 fputs_unfiltered (" (missing implementation)", stb);
2155 make_cleanup_ui_file_delete (stb);
2158 do_cleanups (cleanup);
2161 /* FIXME: This is just a hack so we can get some extra commands going.
2162 We don't want to channel things through the CLI, but call libgdb directly.
2163 Use only for synchronous commands. */
2166 mi_execute_cli_command (const char *cmd, int args_p, const char *args)
2170 struct cleanup *old_cleanups;
2174 run = xstrprintf ("%s %s", cmd, args);
2176 run = xstrdup (cmd);
2178 /* FIXME: gdb_???? */
2179 fprintf_unfiltered (gdb_stdout, "cli=%s run=%s\n",
2181 old_cleanups = make_cleanup (xfree, run);
2182 execute_command (run, 0 /* from_tty */ );
2183 do_cleanups (old_cleanups);
2189 mi_execute_async_cli_command (char *cli_command, char **argv, int argc)
2191 struct cleanup *old_cleanups;
2194 if (target_can_async_p ())
2195 run = xstrprintf ("%s %s&", cli_command, argc ? *argv : "");
2197 run = xstrprintf ("%s %s", cli_command, argc ? *argv : "");
2198 old_cleanups = make_cleanup (xfree, run);
2200 execute_command (run, 0 /* from_tty */ );
2202 /* Do this before doing any printing. It would appear that some
2203 print code leaves garbage around in the buffer. */
2204 do_cleanups (old_cleanups);
2208 mi_load_progress (const char *section_name,
2209 unsigned long sent_so_far,
2210 unsigned long total_section,
2211 unsigned long total_sent,
2212 unsigned long grand_total)
2214 struct timeval time_now, delta, update_threshold;
2215 static struct timeval last_update;
2216 static char *previous_sect_name = NULL;
2218 struct ui_out *saved_uiout;
2219 struct ui_out *uiout;
2221 /* This function is called through deprecated_show_load_progress
2222 which means uiout may not be correct. Fix it for the duration
2223 of this function. */
2224 saved_uiout = current_uiout;
2226 if (current_interp_named_p (INTERP_MI)
2227 || current_interp_named_p (INTERP_MI2))
2228 current_uiout = mi_out_new (2);
2229 else if (current_interp_named_p (INTERP_MI1))
2230 current_uiout = mi_out_new (1);
2231 else if (current_interp_named_p (INTERP_MI3))
2232 current_uiout = mi_out_new (3);
2236 uiout = current_uiout;
2238 update_threshold.tv_sec = 0;
2239 update_threshold.tv_usec = 500000;
2240 gettimeofday (&time_now, NULL);
2242 delta.tv_usec = time_now.tv_usec - last_update.tv_usec;
2243 delta.tv_sec = time_now.tv_sec - last_update.tv_sec;
2245 if (delta.tv_usec < 0)
2248 delta.tv_usec += 1000000L;
2251 new_section = (previous_sect_name ?
2252 strcmp (previous_sect_name, section_name) : 1);
2255 struct cleanup *cleanup_tuple;
2257 xfree (previous_sect_name);
2258 previous_sect_name = xstrdup (section_name);
2261 fputs_unfiltered (current_token, raw_stdout);
2262 fputs_unfiltered ("+download", raw_stdout);
2263 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
2264 ui_out_field_string (uiout, "section", section_name);
2265 ui_out_field_int (uiout, "section-size", total_section);
2266 ui_out_field_int (uiout, "total-size", grand_total);
2267 do_cleanups (cleanup_tuple);
2268 mi_out_put (uiout, raw_stdout);
2269 fputs_unfiltered ("\n", raw_stdout);
2270 gdb_flush (raw_stdout);
2273 if (delta.tv_sec >= update_threshold.tv_sec &&
2274 delta.tv_usec >= update_threshold.tv_usec)
2276 struct cleanup *cleanup_tuple;
2278 last_update.tv_sec = time_now.tv_sec;
2279 last_update.tv_usec = time_now.tv_usec;
2281 fputs_unfiltered (current_token, raw_stdout);
2282 fputs_unfiltered ("+download", raw_stdout);
2283 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
2284 ui_out_field_string (uiout, "section", section_name);
2285 ui_out_field_int (uiout, "section-sent", sent_so_far);
2286 ui_out_field_int (uiout, "section-size", total_section);
2287 ui_out_field_int (uiout, "total-sent", total_sent);
2288 ui_out_field_int (uiout, "total-size", grand_total);
2289 do_cleanups (cleanup_tuple);
2290 mi_out_put (uiout, raw_stdout);
2291 fputs_unfiltered ("\n", raw_stdout);
2292 gdb_flush (raw_stdout);
2296 current_uiout = saved_uiout;
2300 timestamp (struct mi_timestamp *tv)
2302 gettimeofday (&tv->wallclock, NULL);
2303 #ifdef HAVE_GETRUSAGE
2304 getrusage (RUSAGE_SELF, &rusage);
2305 tv->utime.tv_sec = rusage.ru_utime.tv_sec;
2306 tv->utime.tv_usec = rusage.ru_utime.tv_usec;
2307 tv->stime.tv_sec = rusage.ru_stime.tv_sec;
2308 tv->stime.tv_usec = rusage.ru_stime.tv_usec;
2311 long usec = get_run_time ();
2313 tv->utime.tv_sec = usec/1000000L;
2314 tv->utime.tv_usec = usec - 1000000L*tv->utime.tv_sec;
2315 tv->stime.tv_sec = 0;
2316 tv->stime.tv_usec = 0;
2322 print_diff_now (struct mi_timestamp *start)
2324 struct mi_timestamp now;
2327 print_diff (start, &now);
2331 mi_print_timing_maybe (void)
2333 /* If the command is -enable-timing then do_timings may be true
2334 whilst current_command_ts is not initialized. */
2335 if (do_timings && current_command_ts)
2336 print_diff_now (current_command_ts);
2340 timeval_diff (struct timeval start, struct timeval end)
2342 return ((end.tv_sec - start.tv_sec) * 1000000L)
2343 + (end.tv_usec - start.tv_usec);
2347 print_diff (struct mi_timestamp *start, struct mi_timestamp *end)
2351 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
2352 timeval_diff (start->wallclock, end->wallclock) / 1000000.0,
2353 timeval_diff (start->utime, end->utime) / 1000000.0,
2354 timeval_diff (start->stime, end->stime) / 1000000.0);
2358 mi_cmd_trace_define_variable (char *command, char **argv, int argc)
2360 struct expression *expr;
2361 LONGEST initval = 0;
2362 struct trace_state_variable *tsv;
2365 if (argc != 1 && argc != 2)
2366 error (_("Usage: -trace-define-variable VARIABLE [VALUE]"));
2370 error (_("Name of trace variable should start with '$'"));
2372 validate_trace_state_variable_name (name);
2374 tsv = find_trace_state_variable (name);
2376 tsv = create_trace_state_variable (name);
2379 initval = value_as_long (parse_and_eval (argv[1]));
2381 tsv->initial_value = initval;
2385 mi_cmd_trace_list_variables (char *command, char **argv, int argc)
2388 error (_("-trace-list-variables: no arguments allowed"));
2390 tvariables_info_1 ();
2394 mi_cmd_trace_find (char *command, char **argv, int argc)
2399 error (_("trace selection mode is required"));
2403 if (strcmp (mode, "none") == 0)
2405 tfind_1 (tfind_number, -1, 0, 0, 0);
2409 if (current_trace_status ()->running)
2410 error (_("May not look at trace frames while trace is running."));
2412 if (strcmp (mode, "frame-number") == 0)
2415 error (_("frame number is required"));
2416 tfind_1 (tfind_number, atoi (argv[1]), 0, 0, 0);
2418 else if (strcmp (mode, "tracepoint-number") == 0)
2421 error (_("tracepoint number is required"));
2422 tfind_1 (tfind_tp, atoi (argv[1]), 0, 0, 0);
2424 else if (strcmp (mode, "pc") == 0)
2427 error (_("PC is required"));
2428 tfind_1 (tfind_pc, 0, parse_and_eval_address (argv[1]), 0, 0);
2430 else if (strcmp (mode, "pc-inside-range") == 0)
2433 error (_("Start and end PC are required"));
2434 tfind_1 (tfind_range, 0, parse_and_eval_address (argv[1]),
2435 parse_and_eval_address (argv[2]), 0);
2437 else if (strcmp (mode, "pc-outside-range") == 0)
2440 error (_("Start and end PC are required"));
2441 tfind_1 (tfind_outside, 0, parse_and_eval_address (argv[1]),
2442 parse_and_eval_address (argv[2]), 0);
2444 else if (strcmp (mode, "line") == 0)
2446 struct symtabs_and_lines sals;
2447 struct symtab_and_line sal;
2448 static CORE_ADDR start_pc, end_pc;
2449 struct cleanup *back_to;
2452 error (_("Line is required"));
2454 sals = decode_line_with_current_source (argv[1],
2455 DECODE_LINE_FUNFIRSTLINE);
2456 back_to = make_cleanup (xfree, sals.sals);
2460 if (sal.symtab == 0)
2461 error (_("Could not find the specified line"));
2463 if (sal.line > 0 && find_line_pc_range (sal, &start_pc, &end_pc))
2464 tfind_1 (tfind_range, 0, start_pc, end_pc - 1, 0);
2466 error (_("Could not find the specified line"));
2468 do_cleanups (back_to);
2471 error (_("Invalid mode '%s'"), mode);
2473 if (has_stack_frames () || get_traceframe_number () >= 0)
2474 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
2478 mi_cmd_trace_save (char *command, char **argv, int argc)
2480 int target_saves = 0;
2481 int generate_ctf = 0;
2488 TARGET_SAVE_OPT, CTF_OPT
2490 static const struct mi_opt opts[] =
2492 {"r", TARGET_SAVE_OPT, 0},
2493 {"ctf", CTF_OPT, 0},
2499 int opt = mi_getopt ("-trace-save", argc, argv, opts,
2504 switch ((enum opt) opt)
2506 case TARGET_SAVE_OPT:
2514 filename = argv[oind];
2517 trace_save_ctf (filename, target_saves);
2519 trace_save_tfile (filename, target_saves);
2523 mi_cmd_trace_start (char *command, char **argv, int argc)
2525 start_tracing (NULL);
2529 mi_cmd_trace_status (char *command, char **argv, int argc)
2531 trace_status_mi (0);
2535 mi_cmd_trace_stop (char *command, char **argv, int argc)
2537 stop_tracing (NULL);
2538 trace_status_mi (1);
2541 /* Implement the "-ada-task-info" command. */
2544 mi_cmd_ada_task_info (char *command, char **argv, int argc)
2546 if (argc != 0 && argc != 1)
2547 error (_("Invalid MI command"));
2549 print_ada_task_info (current_uiout, argv[0], current_inferior ());