3 Copyright (C) 2000-2005, 2007-2012 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"
58 #if defined HAVE_SYS_RESOURCE_H
59 #include <sys/resource.h>
73 struct ui_file *raw_stdout;
75 /* This is used to pass the current command timestamp down to
76 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 were
83 explicitly specified. This variable keeps the current parsed
84 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 (current_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);
217 proceed_thread_callback (struct thread_info *thread, void *arg)
219 int pid = *(int *)arg;
221 proceed_thread (thread, pid);
226 exec_continue (char **argv, int argc)
230 /* In non-stop mode, 'resume' always resumes a single thread.
231 Therefore, to resume all threads of the current inferior, or
232 all threads in all inferiors, we need to iterate over
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)
244 = find_inferior_id (current_context->thread_group);
248 iterate_over_threads (proceed_thread_callback, &pid);
249 do_cleanups (back_to);
258 struct cleanup *back_to = make_cleanup_restore_integer (&sched_multi);
260 if (current_context->all)
267 /* In all-stop mode, -exec-continue traditionally resumed
268 either all threads, or one thread, depending on the
269 'scheduler-locking' variable. Let's continue to do the
273 do_cleanups (back_to);
278 exec_direction_forward (void *notused)
280 execution_direction = EXEC_FORWARD;
284 exec_reverse_continue (char **argv, int argc)
286 enum exec_direction_kind dir = execution_direction;
287 struct cleanup *old_chain;
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
326 around with the token variables, in order to display the current
327 token in the result of the interrupt command, and the previous
328 execution token when the target finally stops. See comments in
332 mi_cmd_exec_interrupt (char *command, char **argv, int argc)
334 /* In all-stop mode, everything stops, so we don't need to try
335 anything specific. */
338 interrupt_target_1 (0);
342 if (current_context->all)
344 /* This will interrupt all threads in all inferiors. */
345 interrupt_target_1 (1);
347 else if (current_context->thread_group != -1)
349 struct inferior *inf = find_inferior_id (current_context->thread_group);
351 iterate_over_threads (interrupt_thread_callback, &inf->pid);
355 /* Interrupt just the current thread -- either explicitly
356 specified via --thread or whatever was current before
357 MI command was sent. */
358 interrupt_target_1 (0);
363 run_one_inferior (struct inferior *inf, void *arg)
367 if (inf->pid != ptid_get_pid (inferior_ptid))
369 struct thread_info *tp;
371 tp = any_thread_of_process (inf->pid);
373 error (_("Inferior has no threads."));
375 switch_to_thread (tp->ptid);
380 set_current_inferior (inf);
381 switch_to_thread (null_ptid);
382 set_current_program_space (inf->pspace);
384 mi_execute_cli_command ("run", target_can_async_p (),
385 target_can_async_p () ? "&" : NULL);
390 mi_cmd_exec_run (char *command, char **argv, int argc)
392 if (current_context->all)
394 struct cleanup *back_to = save_current_space_and_thread ();
396 iterate_over_inferiors (run_one_inferior, NULL);
397 do_cleanups (back_to);
401 mi_execute_cli_command ("run", target_can_async_p (),
402 target_can_async_p () ? "&" : NULL);
408 find_thread_of_process (struct thread_info *ti, void *p)
412 if (PIDGET (ti->ptid) == pid && !is_exited (ti->ptid))
419 mi_cmd_target_detach (char *command, char **argv, int argc)
421 if (argc != 0 && argc != 1)
422 error (_("Usage: -target-detach [pid | thread-group]"));
426 struct thread_info *tp;
430 /* First see if we are dealing with a thread-group id. */
433 struct inferior *inf;
434 int id = strtoul (argv[0] + 1, &end, 0);
437 error (_("Invalid syntax of thread-group id '%s'"), argv[0]);
439 inf = find_inferior_id (id);
441 error (_("Non-existent thread-group id '%d'"), id);
447 /* We must be dealing with a pid. */
448 pid = strtol (argv[0], &end, 10);
451 error (_("Invalid identifier '%s'"), argv[0]);
454 /* Pick any thread in the desired process. Current
455 target_detach detaches from the parent of inferior_ptid. */
456 tp = iterate_over_threads (find_thread_of_process, &pid);
458 error (_("Thread group is empty"));
460 switch_to_thread (tp->ptid);
463 detach_command (NULL, 0);
467 mi_cmd_thread_select (char *command, char **argv, int argc)
470 char *mi_error_message;
473 error (_("-thread-select: USAGE: threadnum."));
475 rc = gdb_thread_select (current_uiout, argv[0], &mi_error_message);
477 if (rc == GDB_RC_FAIL)
479 make_cleanup (xfree, mi_error_message);
480 error ("%s", mi_error_message);
485 mi_cmd_thread_list_ids (char *command, char **argv, int argc)
488 char *mi_error_message;
491 error (_("-thread-list-ids: No arguments required."));
493 rc = gdb_list_thread_ids (current_uiout, &mi_error_message);
495 if (rc == GDB_RC_FAIL)
497 make_cleanup (xfree, mi_error_message);
498 error ("%s", mi_error_message);
503 mi_cmd_thread_info (char *command, char **argv, int argc)
505 if (argc != 0 && argc != 1)
506 error (_("Invalid MI command"));
508 print_thread_info (current_uiout, argv[0], -1);
513 struct collect_cores_data
521 collect_cores (struct thread_info *ti, void *xdata)
523 struct collect_cores_data *data = xdata;
525 if (ptid_get_pid (ti->ptid) == data->pid)
527 int core = target_core_of_thread (ti->ptid);
530 VEC_safe_push (int, data->cores, core);
537 unique (int *b, int *e)
547 struct print_one_inferior_data
550 VEC (int) *inferiors;
554 print_one_inferior (struct inferior *inferior, void *xdata)
556 struct print_one_inferior_data *top_data = xdata;
557 struct ui_out *uiout = current_uiout;
559 if (VEC_empty (int, top_data->inferiors)
560 || bsearch (&(inferior->pid), VEC_address (int, top_data->inferiors),
561 VEC_length (int, top_data->inferiors), sizeof (int),
562 compare_positive_ints))
564 struct collect_cores_data data;
565 struct cleanup *back_to
566 = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
568 ui_out_field_fmt (uiout, "id", "i%d", inferior->num);
569 ui_out_field_string (uiout, "type", "process");
570 if (inferior->pid != 0)
571 ui_out_field_int (uiout, "pid", inferior->pid);
573 if (inferior->pspace->ebfd)
575 ui_out_field_string (uiout, "executable",
576 bfd_get_filename (inferior->pspace->ebfd));
580 if (inferior->pid != 0)
582 data.pid = inferior->pid;
583 iterate_over_threads (collect_cores, &data);
586 if (!VEC_empty (int, data.cores))
589 struct cleanup *back_to_2 =
590 make_cleanup_ui_out_list_begin_end (uiout, "cores");
592 qsort (VEC_address (int, data.cores),
593 VEC_length (int, data.cores), sizeof (int),
594 compare_positive_ints);
596 b = VEC_address (int, data.cores);
597 e = b + VEC_length (int, data.cores);
601 ui_out_field_int (uiout, NULL, *b);
603 do_cleanups (back_to_2);
606 if (top_data->recurse)
607 print_thread_info (uiout, NULL, inferior->pid);
609 do_cleanups (back_to);
615 /* Output a field named 'cores' with a list as the value. The
616 elements of the list are obtained by splitting 'cores' on
620 output_cores (struct ui_out *uiout, const char *field_name, const char *xcores)
622 struct cleanup *back_to = make_cleanup_ui_out_list_begin_end (uiout,
624 char *cores = xstrdup (xcores);
627 make_cleanup (xfree, cores);
629 for (p = strtok (p, ","); p; p = strtok (NULL, ","))
630 ui_out_field_string (uiout, NULL, p);
632 do_cleanups (back_to);
636 free_vector_of_ints (void *xvector)
638 VEC (int) **vector = xvector;
640 VEC_free (int, *vector);
644 do_nothing (splay_tree_key k)
649 free_vector_of_osdata_items (splay_tree_value xvalue)
651 VEC (osdata_item_s) *value = (VEC (osdata_item_s) *) xvalue;
653 /* We don't free the items itself, it will be done separately. */
654 VEC_free (osdata_item_s, value);
658 splay_tree_int_comparator (splay_tree_key xa, splay_tree_key xb)
667 free_splay_tree (void *xt)
670 splay_tree_delete (t);
674 list_available_thread_groups (VEC (int) *ids, int recurse)
677 struct osdata_item *item;
679 struct ui_out *uiout = current_uiout;
681 /* This keeps a map from integer (pid) to VEC (struct osdata_item *)*
682 The vector contains information about all threads for the given pid.
683 This is assigned an initial value to avoid "may be used uninitialized"
685 splay_tree tree = NULL;
687 /* get_osdata will throw if it cannot return data. */
688 data = get_osdata ("processes");
689 make_cleanup_osdata_free (data);
693 struct osdata *threads = get_osdata ("threads");
695 make_cleanup_osdata_free (threads);
696 tree = splay_tree_new (splay_tree_int_comparator,
698 free_vector_of_osdata_items);
699 make_cleanup (free_splay_tree, tree);
702 VEC_iterate (osdata_item_s, threads->items,
706 const char *pid = get_osdata_column (item, "pid");
707 int pid_i = strtoul (pid, NULL, 0);
708 VEC (osdata_item_s) *vec = 0;
710 splay_tree_node n = splay_tree_lookup (tree, pid_i);
713 VEC_safe_push (osdata_item_s, vec, item);
714 splay_tree_insert (tree, pid_i, (splay_tree_value)vec);
718 vec = (VEC (osdata_item_s) *) n->value;
719 VEC_safe_push (osdata_item_s, vec, item);
720 n->value = (splay_tree_value) vec;
725 make_cleanup_ui_out_list_begin_end (uiout, "groups");
728 VEC_iterate (osdata_item_s, data->items,
732 struct cleanup *back_to;
734 const char *pid = get_osdata_column (item, "pid");
735 const char *cmd = get_osdata_column (item, "command");
736 const char *user = get_osdata_column (item, "user");
737 const char *cores = get_osdata_column (item, "cores");
739 int pid_i = strtoul (pid, NULL, 0);
741 /* At present, the target will return all available processes
742 and if information about specific ones was required, we filter
743 undesired processes here. */
744 if (ids && bsearch (&pid_i, VEC_address (int, ids),
745 VEC_length (int, ids),
746 sizeof (int), compare_positive_ints) == NULL)
750 back_to = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
752 ui_out_field_fmt (uiout, "id", "%s", pid);
753 ui_out_field_string (uiout, "type", "process");
755 ui_out_field_string (uiout, "description", cmd);
757 ui_out_field_string (uiout, "user", user);
759 output_cores (uiout, "cores", cores);
763 splay_tree_node n = splay_tree_lookup (tree, pid_i);
766 VEC (osdata_item_s) *children = (VEC (osdata_item_s) *) n->value;
767 struct osdata_item *child;
770 make_cleanup_ui_out_list_begin_end (uiout, "threads");
773 VEC_iterate (osdata_item_s, children, ix_child, child);
776 struct cleanup *back_to_2 =
777 make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
778 const char *tid = get_osdata_column (child, "tid");
779 const char *tcore = get_osdata_column (child, "core");
781 ui_out_field_string (uiout, "id", tid);
783 ui_out_field_string (uiout, "core", tcore);
785 do_cleanups (back_to_2);
790 do_cleanups (back_to);
795 mi_cmd_list_thread_groups (char *command, char **argv, int argc)
797 struct ui_out *uiout = current_uiout;
798 struct cleanup *back_to;
805 AVAILABLE_OPT, RECURSE_OPT
807 static const struct mi_opt opts[] =
809 {"-available", AVAILABLE_OPT, 0},
810 {"-recurse", RECURSE_OPT, 1},
819 int opt = mi_getopt ("-list-thread-groups", argc, argv, opts,
824 switch ((enum opt) opt)
830 if (strcmp (oarg, "0") == 0)
832 else if (strcmp (oarg, "1") == 0)
835 error (_("only '0' and '1' are valid values "
836 "for the '--recurse' option"));
841 for (; oind < argc; ++oind)
846 if (*(argv[oind]) != 'i')
847 error (_("invalid syntax of group id '%s'"), argv[oind]);
849 inf = strtoul (argv[oind] + 1, &end, 0);
852 error (_("invalid syntax of group id '%s'"), argv[oind]);
853 VEC_safe_push (int, ids, inf);
855 if (VEC_length (int, ids) > 1)
856 qsort (VEC_address (int, ids),
857 VEC_length (int, ids),
858 sizeof (int), compare_positive_ints);
860 back_to = make_cleanup (free_vector_of_ints, &ids);
864 list_available_thread_groups (ids, recurse);
866 else if (VEC_length (int, ids) == 1)
868 /* Local thread groups, single id. */
869 int id = *VEC_address (int, ids);
870 struct inferior *inf = find_inferior_id (id);
873 error (_("Non-existent thread group id '%d'"), id);
875 print_thread_info (uiout, NULL, inf->pid);
879 struct print_one_inferior_data data;
881 data.recurse = recurse;
882 data.inferiors = ids;
884 /* Local thread groups. Either no explicit ids -- and we
885 print everything, or several explicit ids. In both cases,
886 we print more than one group, and have to use 'groups'
887 as the top-level element. */
888 make_cleanup_ui_out_list_begin_end (uiout, "groups");
889 update_thread_list ();
890 iterate_over_inferiors (print_one_inferior, &data);
893 do_cleanups (back_to);
897 mi_cmd_data_list_register_names (char *command, char **argv, int argc)
899 struct gdbarch *gdbarch;
900 struct ui_out *uiout = current_uiout;
903 struct cleanup *cleanup;
905 /* Note that the test for a valid register must include checking the
906 gdbarch_register_name because gdbarch_num_regs may be allocated
907 for the union of the register sets within a family of related
908 processors. In this case, some entries of gdbarch_register_name
909 will change depending upon the particular processor being
912 gdbarch = get_current_arch ();
913 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
915 cleanup = make_cleanup_ui_out_list_begin_end (uiout, "register-names");
917 if (argc == 0) /* No args, just do all the regs. */
923 if (gdbarch_register_name (gdbarch, regnum) == NULL
924 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
925 ui_out_field_string (uiout, NULL, "");
927 ui_out_field_string (uiout, NULL,
928 gdbarch_register_name (gdbarch, regnum));
932 /* Else, list of register #s, just do listed regs. */
933 for (i = 0; i < argc; i++)
935 regnum = atoi (argv[i]);
936 if (regnum < 0 || regnum >= numregs)
937 error (_("bad register number"));
939 if (gdbarch_register_name (gdbarch, regnum) == NULL
940 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
941 ui_out_field_string (uiout, NULL, "");
943 ui_out_field_string (uiout, NULL,
944 gdbarch_register_name (gdbarch, regnum));
946 do_cleanups (cleanup);
950 mi_cmd_data_list_changed_registers (char *command, char **argv, int argc)
952 static struct regcache *this_regs = NULL;
953 struct ui_out *uiout = current_uiout;
954 struct regcache *prev_regs;
955 struct gdbarch *gdbarch;
956 int regnum, numregs, changed;
958 struct cleanup *cleanup;
960 /* The last time we visited this function, the current frame's
961 register contents were saved in THIS_REGS. Move THIS_REGS over
962 to PREV_REGS, and refresh THIS_REGS with the now-current register
965 prev_regs = this_regs;
966 this_regs = frame_save_as_regcache (get_selected_frame (NULL));
967 cleanup = make_cleanup_regcache_xfree (prev_regs);
969 /* Note that the test for a valid register must include checking the
970 gdbarch_register_name because gdbarch_num_regs may be allocated
971 for the union of the register sets within a family of related
972 processors. In this case, some entries of gdbarch_register_name
973 will change depending upon the particular processor being
976 gdbarch = get_regcache_arch (this_regs);
977 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
979 make_cleanup_ui_out_list_begin_end (uiout, "changed-registers");
983 /* No args, just do all the regs. */
988 if (gdbarch_register_name (gdbarch, regnum) == NULL
989 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
991 changed = register_changed_p (regnum, prev_regs, this_regs);
993 error (_("-data-list-changed-registers: "
994 "Unable to read register contents."));
996 ui_out_field_int (uiout, NULL, regnum);
1000 /* Else, list of register #s, just do listed regs. */
1001 for (i = 0; i < argc; i++)
1003 regnum = atoi (argv[i]);
1007 && gdbarch_register_name (gdbarch, regnum) != NULL
1008 && *gdbarch_register_name (gdbarch, regnum) != '\000')
1010 changed = register_changed_p (regnum, prev_regs, this_regs);
1012 error (_("-data-list-changed-registers: "
1013 "Unable to read register contents."));
1015 ui_out_field_int (uiout, NULL, regnum);
1018 error (_("bad register number"));
1020 do_cleanups (cleanup);
1024 register_changed_p (int regnum, struct regcache *prev_regs,
1025 struct regcache *this_regs)
1027 struct gdbarch *gdbarch = get_regcache_arch (this_regs);
1028 gdb_byte prev_buffer[MAX_REGISTER_SIZE];
1029 gdb_byte this_buffer[MAX_REGISTER_SIZE];
1030 enum register_status prev_status;
1031 enum register_status this_status;
1033 /* First time through or after gdbarch change consider all registers
1035 if (!prev_regs || get_regcache_arch (prev_regs) != gdbarch)
1038 /* Get register contents and compare. */
1039 prev_status = regcache_cooked_read (prev_regs, regnum, prev_buffer);
1040 this_status = regcache_cooked_read (this_regs, regnum, this_buffer);
1042 if (this_status != prev_status)
1044 else if (this_status == REG_VALID)
1045 return memcmp (prev_buffer, this_buffer,
1046 register_size (gdbarch, regnum)) != 0;
1051 /* Return a list of register number and value pairs. The valid
1052 arguments expected are: a letter indicating the format in which to
1053 display the registers contents. This can be one of: x
1054 (hexadecimal), d (decimal), N (natural), t (binary), o (octal), r
1055 (raw). After the format argument there can be a sequence of
1056 numbers, indicating which registers to fetch the content of. If
1057 the format is the only argument, a list of all the registers with
1058 their values is returned. */
1061 mi_cmd_data_list_register_values (char *command, char **argv, int argc)
1063 struct ui_out *uiout = current_uiout;
1064 struct frame_info *frame;
1065 struct gdbarch *gdbarch;
1066 int regnum, numregs, format;
1068 struct cleanup *list_cleanup, *tuple_cleanup;
1070 /* Note that the test for a valid register must include checking the
1071 gdbarch_register_name because gdbarch_num_regs may be allocated
1072 for the union of the register sets within a family of related
1073 processors. In this case, some entries of gdbarch_register_name
1074 will change depending upon the particular processor being
1078 error (_("-data-list-register-values: Usage: "
1079 "-data-list-register-values <format> [<regnum1>...<regnumN>]"));
1081 format = (int) argv[0][0];
1083 frame = get_selected_frame (NULL);
1084 gdbarch = get_frame_arch (frame);
1085 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
1087 list_cleanup = make_cleanup_ui_out_list_begin_end (uiout, "register-values");
1091 /* No args, beside the format: do all the regs. */
1096 if (gdbarch_register_name (gdbarch, regnum) == NULL
1097 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
1099 tuple_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1100 ui_out_field_int (uiout, "number", regnum);
1101 get_register (frame, regnum, format);
1102 do_cleanups (tuple_cleanup);
1106 /* Else, list of register #s, just do listed regs. */
1107 for (i = 1; i < argc; i++)
1109 regnum = atoi (argv[i]);
1113 && gdbarch_register_name (gdbarch, regnum) != NULL
1114 && *gdbarch_register_name (gdbarch, regnum) != '\000')
1116 tuple_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1117 ui_out_field_int (uiout, "number", regnum);
1118 get_register (frame, regnum, format);
1119 do_cleanups (tuple_cleanup);
1122 error (_("bad register number"));
1124 do_cleanups (list_cleanup);
1127 /* Output one register's contents in the desired format. */
1130 get_register (struct frame_info *frame, int regnum, int format)
1132 struct gdbarch *gdbarch = get_frame_arch (frame);
1133 struct ui_out *uiout = current_uiout;
1135 enum lval_type lval;
1136 struct ui_stream *stb;
1139 stb = ui_out_stream_new (uiout);
1144 val = get_frame_register_value (frame, regnum);
1146 if (value_optimized_out (val))
1147 error (_("Optimized out"));
1152 char *ptr, buf[1024];
1153 const gdb_byte *valaddr = value_contents_for_printing (val);
1157 for (j = 0; j < register_size (gdbarch, regnum); j++)
1159 int idx = gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG ?
1160 j : register_size (gdbarch, regnum) - 1 - j;
1162 sprintf (ptr, "%02x", (unsigned char) valaddr[idx]);
1165 ui_out_field_string (uiout, "value", buf);
1169 struct value_print_options opts;
1171 get_formatted_print_options (&opts, format);
1173 val_print (value_type (val),
1174 value_contents_for_printing (val),
1175 value_embedded_offset (val), 0,
1176 stb->stream, 0, val, &opts, current_language);
1177 ui_out_field_stream (uiout, "value", stb);
1178 ui_out_stream_delete (stb);
1182 /* Write given values into registers. The registers and values are
1183 given as pairs. The corresponding MI command is
1184 -data-write-register-values <format>
1185 [<regnum1> <value1>...<regnumN> <valueN>] */
1187 mi_cmd_data_write_register_values (char *command, char **argv, int argc)
1189 struct regcache *regcache;
1190 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 format = (int) argv[0][0];
1211 if (!target_has_registers)
1212 error (_("-data-write-register-values: No registers."));
1215 error (_("-data-write-register-values: No regs and values specified."));
1218 error (_("-data-write-register-values: "
1219 "Regs and vals are not in pairs."));
1221 for (i = 1; i < argc; i = i + 2)
1223 int regnum = atoi (argv[i]);
1225 if (regnum >= 0 && regnum < numregs
1226 && gdbarch_register_name (gdbarch, regnum)
1227 && *gdbarch_register_name (gdbarch, regnum))
1231 /* Get the value as a number. */
1232 value = parse_and_eval_address (argv[i + 1]);
1234 /* Write it down. */
1235 regcache_cooked_write_signed (regcache, regnum, value);
1238 error (_("bad register number"));
1242 /* Evaluate the value of the argument. The argument is an
1243 expression. If the expression contains spaces it needs to be
1244 included in double quotes. */
1247 mi_cmd_data_evaluate_expression (char *command, char **argv, int argc)
1249 struct expression *expr;
1250 struct cleanup *old_chain = NULL;
1252 struct ui_stream *stb = NULL;
1253 struct value_print_options opts;
1254 struct ui_out *uiout = current_uiout;
1256 stb = ui_out_stream_new (uiout);
1260 ui_out_stream_delete (stb);
1261 error (_("-data-evaluate-expression: "
1262 "Usage: -data-evaluate-expression expression"));
1265 expr = parse_expression (argv[0]);
1267 old_chain = make_cleanup (free_current_contents, &expr);
1269 val = evaluate_expression (expr);
1271 /* Print the result of the expression evaluation. */
1272 get_user_print_options (&opts);
1274 common_val_print (val, stb->stream, 0, &opts, current_language);
1276 ui_out_field_stream (uiout, "value", stb);
1277 ui_out_stream_delete (stb);
1279 do_cleanups (old_chain);
1282 /* This is the -data-read-memory command.
1284 ADDR: start address of data to be dumped.
1285 WORD-FORMAT: a char indicating format for the ``word''. See
1287 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
1288 NR_ROW: Number of rows.
1289 NR_COL: The number of colums (words per row).
1290 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
1291 ASCHAR for unprintable characters.
1293 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
1294 displayes them. Returns:
1296 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
1299 The number of bytes read is SIZE*ROW*COL. */
1302 mi_cmd_data_read_memory (char *command, char **argv, int argc)
1304 struct gdbarch *gdbarch = get_current_arch ();
1305 struct ui_out *uiout = current_uiout;
1306 struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
1308 long total_bytes, nr_cols, nr_rows;
1310 struct type *word_type;
1323 static const struct mi_opt opts[] =
1325 {"o", OFFSET_OPT, 1},
1331 int opt = mi_getopt ("-data-read-memory", argc, argv, opts,
1336 switch ((enum opt) opt)
1339 offset = atol (oarg);
1346 if (argc < 5 || argc > 6)
1347 error (_("-data-read-memory: Usage: "
1348 "ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR]."));
1350 /* Extract all the arguments. */
1352 /* Start address of the memory dump. */
1353 addr = parse_and_eval_address (argv[0]) + offset;
1354 /* The format character to use when displaying a memory word. See
1355 the ``x'' command. */
1356 word_format = argv[1][0];
1357 /* The size of the memory word. */
1358 word_size = atol (argv[2]);
1362 word_type = builtin_type (gdbarch)->builtin_int8;
1366 word_type = builtin_type (gdbarch)->builtin_int16;
1370 word_type = builtin_type (gdbarch)->builtin_int32;
1374 word_type = builtin_type (gdbarch)->builtin_int64;
1378 word_type = builtin_type (gdbarch)->builtin_int8;
1381 /* The number of rows. */
1382 nr_rows = atol (argv[3]);
1384 error (_("-data-read-memory: invalid number of rows."));
1386 /* Number of bytes per row. */
1387 nr_cols = atol (argv[4]);
1389 error (_("-data-read-memory: invalid number of columns."));
1391 /* The un-printable character when printing ascii. */
1397 /* Create a buffer and read it in. */
1398 total_bytes = word_size * nr_rows * nr_cols;
1399 mbuf = xcalloc (total_bytes, 1);
1400 make_cleanup (xfree, mbuf);
1402 /* Dispatch memory reads to the topmost target, not the flattened
1404 nr_bytes = target_read (current_target.beneath,
1405 TARGET_OBJECT_MEMORY, NULL, mbuf,
1408 error (_("Unable to read memory."));
1410 /* Output the header information. */
1411 ui_out_field_core_addr (uiout, "addr", gdbarch, addr);
1412 ui_out_field_int (uiout, "nr-bytes", nr_bytes);
1413 ui_out_field_int (uiout, "total-bytes", total_bytes);
1414 ui_out_field_core_addr (uiout, "next-row",
1415 gdbarch, addr + word_size * nr_cols);
1416 ui_out_field_core_addr (uiout, "prev-row",
1417 gdbarch, addr - word_size * nr_cols);
1418 ui_out_field_core_addr (uiout, "next-page", gdbarch, addr + total_bytes);
1419 ui_out_field_core_addr (uiout, "prev-page", gdbarch, addr - total_bytes);
1421 /* Build the result as a two dimentional table. */
1423 struct ui_stream *stream = ui_out_stream_new (uiout);
1424 struct cleanup *cleanup_list_memory;
1428 cleanup_list_memory = make_cleanup_ui_out_list_begin_end (uiout, "memory");
1429 for (row = 0, row_byte = 0;
1431 row++, row_byte += nr_cols * word_size)
1435 struct cleanup *cleanup_tuple;
1436 struct cleanup *cleanup_list_data;
1437 struct value_print_options opts;
1439 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1440 ui_out_field_core_addr (uiout, "addr", gdbarch, addr + row_byte);
1441 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr +
1443 cleanup_list_data = make_cleanup_ui_out_list_begin_end (uiout, "data");
1444 get_formatted_print_options (&opts, word_format);
1445 for (col = 0, col_byte = row_byte;
1447 col++, col_byte += word_size)
1449 if (col_byte + word_size > nr_bytes)
1451 ui_out_field_string (uiout, NULL, "N/A");
1455 ui_file_rewind (stream->stream);
1456 print_scalar_formatted (mbuf + col_byte, word_type, &opts,
1457 word_asize, stream->stream);
1458 ui_out_field_stream (uiout, NULL, stream);
1461 do_cleanups (cleanup_list_data);
1466 ui_file_rewind (stream->stream);
1467 for (byte = row_byte;
1468 byte < row_byte + word_size * nr_cols; byte++)
1470 if (byte >= nr_bytes)
1471 fputc_unfiltered ('X', stream->stream);
1472 else if (mbuf[byte] < 32 || mbuf[byte] > 126)
1473 fputc_unfiltered (aschar, stream->stream);
1475 fputc_unfiltered (mbuf[byte], stream->stream);
1477 ui_out_field_stream (uiout, "ascii", stream);
1479 do_cleanups (cleanup_tuple);
1481 ui_out_stream_delete (stream);
1482 do_cleanups (cleanup_list_memory);
1484 do_cleanups (cleanups);
1488 mi_cmd_data_read_memory_bytes (char *command, char **argv, int argc)
1490 struct gdbarch *gdbarch = get_current_arch ();
1491 struct ui_out *uiout = current_uiout;
1492 struct cleanup *cleanups;
1495 memory_read_result_s *read_result;
1497 VEC(memory_read_result_s) *result;
1505 static const struct mi_opt opts[] =
1507 {"o", OFFSET_OPT, 1},
1513 int opt = mi_getopt ("-data-read-memory-bytes", argc, argv, opts,
1517 switch ((enum opt) opt)
1520 offset = atol (oarg);
1528 error (_("Usage: [ -o OFFSET ] ADDR LENGTH."));
1530 addr = parse_and_eval_address (argv[0]) + offset;
1531 length = atol (argv[1]);
1533 result = read_memory_robust (current_target.beneath, addr, length);
1535 cleanups = make_cleanup (free_memory_read_result_vector, result);
1537 if (VEC_length (memory_read_result_s, result) == 0)
1538 error (_("Unable to read memory."));
1540 make_cleanup_ui_out_list_begin_end (uiout, "memory");
1542 VEC_iterate (memory_read_result_s, result, ix, read_result);
1545 struct cleanup *t = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1549 ui_out_field_core_addr (uiout, "begin", gdbarch, read_result->begin);
1550 ui_out_field_core_addr (uiout, "offset", gdbarch, read_result->begin
1552 ui_out_field_core_addr (uiout, "end", gdbarch, read_result->end);
1554 data = xmalloc ((read_result->end - read_result->begin) * 2 + 1);
1556 for (i = 0, p = data;
1557 i < (read_result->end - read_result->begin);
1560 sprintf (p, "%02x", read_result->data[i]);
1562 ui_out_field_string (uiout, "contents", data);
1566 do_cleanups (cleanups);
1569 /* Implementation of the -data-write_memory command.
1571 COLUMN_OFFSET: optional argument. Must be preceded by '-o'. The
1572 offset from the beginning of the memory grid row where the cell to
1574 ADDR: start address of the row in the memory grid where the memory
1575 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
1576 the location to write to.
1577 FORMAT: a char indicating format for the ``word''. See
1579 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
1580 VALUE: value to be written into the memory address.
1582 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1587 mi_cmd_data_write_memory (char *command, char **argv, int argc)
1589 struct gdbarch *gdbarch = get_current_arch ();
1590 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1594 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1595 enough when using a compiler other than GCC. */
1598 struct cleanup *old_chain;
1606 static const struct mi_opt opts[] =
1608 {"o", OFFSET_OPT, 1},
1614 int opt = mi_getopt ("-data-write-memory", argc, argv, opts,
1619 switch ((enum opt) opt)
1622 offset = atol (oarg);
1630 error (_("-data-write-memory: Usage: "
1631 "[-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE."));
1633 /* Extract all the arguments. */
1634 /* Start address of the memory dump. */
1635 addr = parse_and_eval_address (argv[0]);
1636 /* The format character to use when displaying a memory word. See
1637 the ``x'' command. */
1638 word_format = argv[1][0];
1639 /* The size of the memory word. */
1640 word_size = atol (argv[2]);
1642 /* Calculate the real address of the write destination. */
1643 addr += (offset * word_size);
1645 /* Get the value as a number. */
1646 value = parse_and_eval_address (argv[3]);
1647 /* Get the value into an array. */
1648 buffer = xmalloc (word_size);
1649 old_chain = make_cleanup (xfree, buffer);
1650 store_signed_integer (buffer, word_size, byte_order, value);
1651 /* Write it down to memory. */
1652 write_memory (addr, buffer, word_size);
1653 /* Free the buffer. */
1654 do_cleanups (old_chain);
1657 /* Implementation of the -data-write-memory-bytes command.
1660 DATA: string of bytes to write at that address. */
1663 mi_cmd_data_write_memory_bytes (char *command, char **argv, int argc)
1669 struct cleanup *back_to;
1672 error (_("Usage: ADDR DATA."));
1674 addr = parse_and_eval_address (argv[0]);
1676 len = strlen (cdata)/2;
1678 data = xmalloc (len);
1679 back_to = make_cleanup (xfree, data);
1681 for (i = 0; i < len; ++i)
1684 sscanf (cdata + i * 2, "%02x", &x);
1685 data[i] = (gdb_byte) x;
1688 r = target_write_memory (addr, data, len);
1690 error (_("Could not write memory"));
1692 do_cleanups (back_to);
1696 mi_cmd_enable_timings (char *command, char **argv, int argc)
1702 if (strcmp (argv[0], "yes") == 0)
1704 else if (strcmp (argv[0], "no") == 0)
1715 error (_("-enable-timings: Usage: %s {yes|no}"), command);
1719 mi_cmd_list_features (char *command, char **argv, int argc)
1723 struct cleanup *cleanup = NULL;
1724 struct ui_out *uiout = current_uiout;
1726 cleanup = make_cleanup_ui_out_list_begin_end (uiout, "features");
1727 ui_out_field_string (uiout, NULL, "frozen-varobjs");
1728 ui_out_field_string (uiout, NULL, "pending-breakpoints");
1729 ui_out_field_string (uiout, NULL, "thread-info");
1730 ui_out_field_string (uiout, NULL, "data-read-memory-bytes");
1731 ui_out_field_string (uiout, NULL, "breakpoint-notifications");
1732 ui_out_field_string (uiout, NULL, "ada-task-info");
1735 ui_out_field_string (uiout, NULL, "python");
1738 do_cleanups (cleanup);
1742 error (_("-list-features should be passed no arguments"));
1746 mi_cmd_list_target_features (char *command, char **argv, int argc)
1750 struct cleanup *cleanup = NULL;
1751 struct ui_out *uiout = current_uiout;
1753 cleanup = make_cleanup_ui_out_list_begin_end (uiout, "features");
1754 if (target_can_async_p ())
1755 ui_out_field_string (uiout, NULL, "async");
1756 if (target_can_execute_reverse)
1757 ui_out_field_string (uiout, NULL, "reverse");
1759 do_cleanups (cleanup);
1763 error (_("-list-target-features should be passed no arguments"));
1767 mi_cmd_add_inferior (char *command, char **argv, int argc)
1769 struct inferior *inf;
1772 error (_("-add-inferior should be passed no arguments"));
1774 inf = add_inferior_with_spaces ();
1776 ui_out_field_fmt (current_uiout, "inferior", "i%d", inf->num);
1779 /* Callback used to find the first inferior other than the current
1783 get_other_inferior (struct inferior *inf, void *arg)
1785 if (inf == current_inferior ())
1792 mi_cmd_remove_inferior (char *command, char **argv, int argc)
1795 struct inferior *inf;
1798 error (_("-remove-inferior should be passed a single argument"));
1800 if (sscanf (argv[0], "i%d", &id) != 1)
1801 error (_("the thread group id is syntactically invalid"));
1803 inf = find_inferior_id (id);
1805 error (_("the specified thread group does not exist"));
1808 error (_("cannot remove an active inferior"));
1810 if (inf == current_inferior ())
1812 struct thread_info *tp = 0;
1813 struct inferior *new_inferior
1814 = iterate_over_inferiors (get_other_inferior, NULL);
1816 if (new_inferior == NULL)
1817 error (_("Cannot remove last inferior"));
1819 set_current_inferior (new_inferior);
1820 if (new_inferior->pid != 0)
1821 tp = any_thread_of_process (new_inferior->pid);
1822 switch_to_thread (tp ? tp->ptid : null_ptid);
1823 set_current_program_space (new_inferior->pspace);
1826 delete_inferior_1 (inf, 1 /* silent */);
1831 /* Execute a command within a safe environment.
1832 Return <0 for error; >=0 for ok.
1834 args->action will tell mi_execute_command what action
1835 to perfrom after the given command has executed (display/suppress
1836 prompt, display error). */
1839 captured_mi_execute_command (struct ui_out *uiout, struct mi_parse *context)
1841 struct cleanup *cleanup;
1844 current_command_ts = context->cmd_start;
1846 current_token = xstrdup (context->token);
1847 cleanup = make_cleanup (free_current_contents, ¤t_token);
1849 running_result_record_printed = 0;
1851 switch (context->op)
1854 /* A MI command was read from the input stream. */
1856 /* FIXME: gdb_???? */
1857 fprintf_unfiltered (raw_stdout, " token=`%s' command=`%s' args=`%s'\n",
1858 context->token, context->command, context->args);
1860 mi_cmd_execute (context);
1862 /* Print the result if there were no errors.
1864 Remember that on the way out of executing a command, you have
1865 to directly use the mi_interp's uiout, since the command
1866 could have reset the interpreter, in which case the current
1867 uiout will most likely crash in the mi_out_* routines. */
1868 if (!running_result_record_printed)
1870 fputs_unfiltered (context->token, raw_stdout);
1871 /* There's no particularly good reason why target-connect results
1872 in not ^done. Should kill ^connected for MI3. */
1873 fputs_unfiltered (strcmp (context->command, "target-select") == 0
1874 ? "^connected" : "^done", raw_stdout);
1875 mi_out_put (uiout, raw_stdout);
1876 mi_out_rewind (uiout);
1877 mi_print_timing_maybe ();
1878 fputs_unfiltered ("\n", raw_stdout);
1881 /* The command does not want anything to be printed. In that
1882 case, the command probably should not have written anything
1883 to uiout, but in case it has written something, discard it. */
1884 mi_out_rewind (uiout);
1891 /* A CLI command was read from the input stream. */
1892 /* This "feature" will be removed as soon as we have a
1893 complete set of mi commands. */
1894 /* Echo the command on the console. */
1895 fprintf_unfiltered (gdb_stdlog, "%s\n", context->command);
1896 /* Call the "console" interpreter. */
1897 argv[0] = "console";
1898 argv[1] = context->command;
1899 mi_cmd_interpreter_exec ("-interpreter-exec", argv, 2);
1901 /* If we changed interpreters, DON'T print out anything. */
1902 if (current_interp_named_p (INTERP_MI)
1903 || current_interp_named_p (INTERP_MI1)
1904 || current_interp_named_p (INTERP_MI2)
1905 || current_interp_named_p (INTERP_MI3))
1907 if (!running_result_record_printed)
1909 fputs_unfiltered (context->token, raw_stdout);
1910 fputs_unfiltered ("^done", raw_stdout);
1911 mi_out_put (uiout, raw_stdout);
1912 mi_out_rewind (uiout);
1913 mi_print_timing_maybe ();
1914 fputs_unfiltered ("\n", raw_stdout);
1917 mi_out_rewind (uiout);
1923 do_cleanups (cleanup);
1926 /* Print a gdb exception to the MI output stream. */
1929 mi_print_exception (const char *token, struct gdb_exception exception)
1931 fputs_unfiltered (token, raw_stdout);
1932 fputs_unfiltered ("^error,msg=\"", raw_stdout);
1933 if (exception.message == NULL)
1934 fputs_unfiltered ("unknown error", raw_stdout);
1936 fputstr_unfiltered (exception.message, '"', raw_stdout);
1937 fputs_unfiltered ("\"\n", raw_stdout);
1941 mi_execute_command (char *cmd, int from_tty)
1944 struct mi_parse *command = NULL;
1945 volatile struct gdb_exception exception;
1947 /* This is to handle EOF (^D). We just quit gdb. */
1948 /* FIXME: we should call some API function here. */
1950 quit_force (NULL, from_tty);
1952 target_log_command (cmd);
1954 TRY_CATCH (exception, RETURN_MASK_ALL)
1956 command = mi_parse (cmd, &token);
1958 if (exception.reason < 0)
1960 mi_print_exception (token, exception);
1965 volatile struct gdb_exception result;
1966 ptid_t previous_ptid = inferior_ptid;
1968 command->token = token;
1972 command->cmd_start = (struct mi_timestamp *)
1973 xmalloc (sizeof (struct mi_timestamp));
1974 timestamp (command->cmd_start);
1977 TRY_CATCH (result, RETURN_MASK_ALL)
1979 captured_mi_execute_command (current_uiout, command);
1981 if (result.reason < 0)
1983 /* The command execution failed and error() was called
1985 mi_print_exception (command->token, result);
1986 mi_out_rewind (current_uiout);
1989 bpstat_do_actions ();
1991 if (/* The notifications are only output when the top-level
1992 interpreter (specified on the command line) is MI. */
1993 ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ()))
1994 /* Don't try report anything if there are no threads --
1995 the program is dead. */
1996 && thread_count () != 0
1997 /* -thread-select explicitly changes thread. If frontend uses that
1998 internally, we don't want to emit =thread-selected, since
1999 =thread-selected is supposed to indicate user's intentions. */
2000 && strcmp (command->command, "thread-select") != 0)
2002 struct mi_interp *mi = top_level_interpreter_data ();
2003 int report_change = 0;
2005 if (command->thread == -1)
2007 report_change = (!ptid_equal (previous_ptid, null_ptid)
2008 && !ptid_equal (inferior_ptid, previous_ptid)
2009 && !ptid_equal (inferior_ptid, null_ptid));
2011 else if (!ptid_equal (inferior_ptid, null_ptid))
2013 struct thread_info *ti = inferior_thread ();
2015 report_change = (ti->num != command->thread);
2020 struct thread_info *ti = inferior_thread ();
2022 target_terminal_ours ();
2023 fprintf_unfiltered (mi->event_channel,
2024 "thread-selected,id=\"%d\"",
2026 gdb_flush (mi->event_channel);
2030 mi_parse_free (command);
2033 fputs_unfiltered ("(gdb) \n", raw_stdout);
2034 gdb_flush (raw_stdout);
2038 mi_cmd_execute (struct mi_parse *parse)
2040 struct cleanup *cleanup;
2042 cleanup = prepare_execute_command ();
2044 if (parse->all && parse->thread_group != -1)
2045 error (_("Cannot specify --thread-group together with --all"));
2047 if (parse->all && parse->thread != -1)
2048 error (_("Cannot specify --thread together with --all"));
2050 if (parse->thread_group != -1 && parse->thread != -1)
2051 error (_("Cannot specify --thread together with --thread-group"));
2053 if (parse->frame != -1 && parse->thread == -1)
2054 error (_("Cannot specify --frame without --thread"));
2056 if (parse->thread_group != -1)
2058 struct inferior *inf = find_inferior_id (parse->thread_group);
2059 struct thread_info *tp = 0;
2062 error (_("Invalid thread group for the --thread-group option"));
2064 set_current_inferior (inf);
2065 /* This behaviour means that if --thread-group option identifies
2066 an inferior with multiple threads, then a random one will be
2067 picked. This is not a problem -- frontend should always
2068 provide --thread if it wishes to operate on a specific
2071 tp = any_thread_of_process (inf->pid);
2072 switch_to_thread (tp ? tp->ptid : null_ptid);
2073 set_current_program_space (inf->pspace);
2076 if (parse->thread != -1)
2078 struct thread_info *tp = find_thread_id (parse->thread);
2081 error (_("Invalid thread id: %d"), parse->thread);
2083 if (is_exited (tp->ptid))
2084 error (_("Thread id: %d has terminated"), parse->thread);
2086 switch_to_thread (tp->ptid);
2089 if (parse->frame != -1)
2091 struct frame_info *fid;
2092 int frame = parse->frame;
2094 fid = find_relative_frame (get_current_frame (), &frame);
2096 /* find_relative_frame was successful */
2099 error (_("Invalid frame id: %d"), frame);
2102 current_context = parse;
2104 if (strncmp (parse->command, "break-", sizeof ("break-") - 1 ) == 0)
2106 make_cleanup_restore_integer (&mi_suppress_breakpoint_notifications);
2107 mi_suppress_breakpoint_notifications = 1;
2110 if (parse->cmd->argv_func != NULL)
2112 parse->cmd->argv_func (parse->command, parse->argv, parse->argc);
2114 else if (parse->cmd->cli.cmd != 0)
2116 /* FIXME: DELETE THIS. */
2117 /* The operation is still implemented by a cli command. */
2118 /* Must be a synchronous one. */
2119 mi_execute_cli_command (parse->cmd->cli.cmd, parse->cmd->cli.args_p,
2124 /* FIXME: DELETE THIS. */
2125 struct ui_file *stb;
2127 stb = mem_fileopen ();
2129 fputs_unfiltered ("Undefined mi command: ", stb);
2130 fputstr_unfiltered (parse->command, '"', stb);
2131 fputs_unfiltered (" (missing implementation)", stb);
2133 make_cleanup_ui_file_delete (stb);
2136 do_cleanups (cleanup);
2139 /* FIXME: This is just a hack so we can get some extra commands going.
2140 We don't want to channel things through the CLI, but call libgdb directly.
2141 Use only for synchronous commands. */
2144 mi_execute_cli_command (const char *cmd, int args_p, const char *args)
2148 struct cleanup *old_cleanups;
2152 run = xstrprintf ("%s %s", cmd, args);
2154 run = xstrdup (cmd);
2156 /* FIXME: gdb_???? */
2157 fprintf_unfiltered (gdb_stdout, "cli=%s run=%s\n",
2159 old_cleanups = make_cleanup (xfree, run);
2160 execute_command (run, 0 /* from_tty */ );
2161 do_cleanups (old_cleanups);
2167 mi_execute_async_cli_command (char *cli_command, char **argv, int argc)
2169 struct cleanup *old_cleanups;
2172 if (target_can_async_p ())
2173 run = xstrprintf ("%s %s&", cli_command, argc ? *argv : "");
2175 run = xstrprintf ("%s %s", cli_command, argc ? *argv : "");
2176 old_cleanups = make_cleanup (xfree, run);
2178 execute_command (run, 0 /* from_tty */ );
2180 /* Do this before doing any printing. It would appear that some
2181 print code leaves garbage around in the buffer. */
2182 do_cleanups (old_cleanups);
2186 mi_load_progress (const char *section_name,
2187 unsigned long sent_so_far,
2188 unsigned long total_section,
2189 unsigned long total_sent,
2190 unsigned long grand_total)
2192 struct timeval time_now, delta, update_threshold;
2193 static struct timeval last_update;
2194 static char *previous_sect_name = NULL;
2196 struct ui_out *saved_uiout;
2197 struct ui_out *uiout;
2199 /* This function is called through deprecated_show_load_progress
2200 which means uiout may not be correct. Fix it for the duration
2201 of this function. */
2202 saved_uiout = current_uiout;
2204 if (current_interp_named_p (INTERP_MI)
2205 || current_interp_named_p (INTERP_MI2))
2206 current_uiout = mi_out_new (2);
2207 else if (current_interp_named_p (INTERP_MI1))
2208 current_uiout = mi_out_new (1);
2209 else if (current_interp_named_p (INTERP_MI3))
2210 current_uiout = mi_out_new (3);
2214 uiout = current_uiout;
2216 update_threshold.tv_sec = 0;
2217 update_threshold.tv_usec = 500000;
2218 gettimeofday (&time_now, NULL);
2220 delta.tv_usec = time_now.tv_usec - last_update.tv_usec;
2221 delta.tv_sec = time_now.tv_sec - last_update.tv_sec;
2223 if (delta.tv_usec < 0)
2226 delta.tv_usec += 1000000L;
2229 new_section = (previous_sect_name ?
2230 strcmp (previous_sect_name, section_name) : 1);
2233 struct cleanup *cleanup_tuple;
2235 xfree (previous_sect_name);
2236 previous_sect_name = xstrdup (section_name);
2239 fputs_unfiltered (current_token, raw_stdout);
2240 fputs_unfiltered ("+download", raw_stdout);
2241 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
2242 ui_out_field_string (uiout, "section", section_name);
2243 ui_out_field_int (uiout, "section-size", total_section);
2244 ui_out_field_int (uiout, "total-size", grand_total);
2245 do_cleanups (cleanup_tuple);
2246 mi_out_put (uiout, raw_stdout);
2247 fputs_unfiltered ("\n", raw_stdout);
2248 gdb_flush (raw_stdout);
2251 if (delta.tv_sec >= update_threshold.tv_sec &&
2252 delta.tv_usec >= update_threshold.tv_usec)
2254 struct cleanup *cleanup_tuple;
2256 last_update.tv_sec = time_now.tv_sec;
2257 last_update.tv_usec = time_now.tv_usec;
2259 fputs_unfiltered (current_token, raw_stdout);
2260 fputs_unfiltered ("+download", raw_stdout);
2261 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
2262 ui_out_field_string (uiout, "section", section_name);
2263 ui_out_field_int (uiout, "section-sent", sent_so_far);
2264 ui_out_field_int (uiout, "section-size", total_section);
2265 ui_out_field_int (uiout, "total-sent", total_sent);
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);
2274 current_uiout = saved_uiout;
2278 timestamp (struct mi_timestamp *tv)
2280 gettimeofday (&tv->wallclock, NULL);
2281 #ifdef HAVE_GETRUSAGE
2282 getrusage (RUSAGE_SELF, &rusage);
2283 tv->utime.tv_sec = rusage.ru_utime.tv_sec;
2284 tv->utime.tv_usec = rusage.ru_utime.tv_usec;
2285 tv->stime.tv_sec = rusage.ru_stime.tv_sec;
2286 tv->stime.tv_usec = rusage.ru_stime.tv_usec;
2289 long usec = get_run_time ();
2291 tv->utime.tv_sec = usec/1000000L;
2292 tv->utime.tv_usec = usec - 1000000L*tv->utime.tv_sec;
2293 tv->stime.tv_sec = 0;
2294 tv->stime.tv_usec = 0;
2300 print_diff_now (struct mi_timestamp *start)
2302 struct mi_timestamp now;
2305 print_diff (start, &now);
2309 mi_print_timing_maybe (void)
2311 /* If the command is -enable-timing then do_timings may be true
2312 whilst current_command_ts is not initialized. */
2313 if (do_timings && current_command_ts)
2314 print_diff_now (current_command_ts);
2318 timeval_diff (struct timeval start, struct timeval end)
2320 return ((end.tv_sec - start.tv_sec) * 1000000L)
2321 + (end.tv_usec - start.tv_usec);
2325 print_diff (struct mi_timestamp *start, struct mi_timestamp *end)
2329 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
2330 timeval_diff (start->wallclock, end->wallclock) / 1000000.0,
2331 timeval_diff (start->utime, end->utime) / 1000000.0,
2332 timeval_diff (start->stime, end->stime) / 1000000.0);
2336 mi_cmd_trace_define_variable (char *command, char **argv, int argc)
2338 struct expression *expr;
2339 struct cleanup *back_to;
2340 LONGEST initval = 0;
2341 struct trace_state_variable *tsv;
2344 if (argc != 1 && argc != 2)
2345 error (_("Usage: -trace-define-variable VARIABLE [VALUE]"));
2347 expr = parse_expression (argv[0]);
2348 back_to = make_cleanup (xfree, expr);
2350 if (expr->nelts == 3 && expr->elts[0].opcode == OP_INTERNALVAR)
2352 struct internalvar *intvar = expr->elts[1].internalvar;
2355 name = internalvar_name (intvar);
2358 if (!name || *name == '\0')
2359 error (_("Invalid name of trace variable"));
2361 tsv = find_trace_state_variable (name);
2363 tsv = create_trace_state_variable (name);
2366 initval = value_as_long (parse_and_eval (argv[1]));
2368 tsv->initial_value = initval;
2370 do_cleanups (back_to);
2374 mi_cmd_trace_list_variables (char *command, char **argv, int argc)
2377 error (_("-trace-list-variables: no arguments allowed"));
2379 tvariables_info_1 ();
2383 mi_cmd_trace_find (char *command, char **argv, int argc)
2388 error (_("trace selection mode is required"));
2392 if (strcmp (mode, "none") == 0)
2394 tfind_1 (tfind_number, -1, 0, 0, 0);
2398 if (current_trace_status ()->running)
2399 error (_("May not look at trace frames while trace is running."));
2401 if (strcmp (mode, "frame-number") == 0)
2404 error (_("frame number is required"));
2405 tfind_1 (tfind_number, atoi (argv[1]), 0, 0, 0);
2407 else if (strcmp (mode, "tracepoint-number") == 0)
2410 error (_("tracepoint number is required"));
2411 tfind_1 (tfind_tp, atoi (argv[1]), 0, 0, 0);
2413 else if (strcmp (mode, "pc") == 0)
2416 error (_("PC is required"));
2417 tfind_1 (tfind_pc, 0, parse_and_eval_address (argv[1]), 0, 0);
2419 else if (strcmp (mode, "pc-inside-range") == 0)
2422 error (_("Start and end PC are required"));
2423 tfind_1 (tfind_range, 0, parse_and_eval_address (argv[1]),
2424 parse_and_eval_address (argv[2]), 0);
2426 else if (strcmp (mode, "pc-outside-range") == 0)
2429 error (_("Start and end PC are required"));
2430 tfind_1 (tfind_outside, 0, parse_and_eval_address (argv[1]),
2431 parse_and_eval_address (argv[2]), 0);
2433 else if (strcmp (mode, "line") == 0)
2435 struct symtabs_and_lines sals;
2436 struct symtab_and_line sal;
2437 static CORE_ADDR start_pc, end_pc;
2438 struct cleanup *back_to;
2441 error (_("Line is required"));
2443 sals = decode_line_spec (argv[1], DECODE_LINE_FUNFIRSTLINE);
2444 back_to = make_cleanup (xfree, sals.sals);
2448 if (sal.symtab == 0)
2449 error (_("Could not find the specified line"));
2451 if (sal.line > 0 && find_line_pc_range (sal, &start_pc, &end_pc))
2452 tfind_1 (tfind_range, 0, start_pc, end_pc - 1, 0);
2454 error (_("Could not find the specified line"));
2456 do_cleanups (back_to);
2459 error (_("Invalid mode '%s'"), mode);
2461 if (has_stack_frames () || get_traceframe_number () >= 0)
2462 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
2466 mi_cmd_trace_save (char *command, char **argv, int argc)
2468 int target_saves = 0;
2471 if (argc != 1 && argc != 2)
2472 error (_("Usage: -trace-save [-r] filename"));
2477 if (strcmp (argv[0], "-r") == 0)
2480 error (_("Invalid option: %s"), argv[0]);
2487 trace_save (filename, target_saves);
2491 mi_cmd_trace_start (char *command, char **argv, int argc)
2493 start_tracing (NULL);
2497 mi_cmd_trace_status (char *command, char **argv, int argc)
2499 trace_status_mi (0);
2503 mi_cmd_trace_stop (char *command, char **argv, int argc)
2505 stop_tracing (NULL);
2506 trace_status_mi (1);
2509 /* Implement the "-ada-task-info" command. */
2512 mi_cmd_ada_task_info (char *command, char **argv, int argc)
2514 if (argc != 0 && argc != 1)
2515 error (_("Invalid MI command"));
2517 print_ada_task_info (current_uiout, argv[0], current_inferior ());