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);
511 struct collect_cores_data
519 collect_cores (struct thread_info *ti, void *xdata)
521 struct collect_cores_data *data = xdata;
523 if (ptid_get_pid (ti->ptid) == data->pid)
525 int core = target_core_of_thread (ti->ptid);
528 VEC_safe_push (int, data->cores, core);
535 unique (int *b, int *e)
545 struct print_one_inferior_data
548 VEC (int) *inferiors;
552 print_one_inferior (struct inferior *inferior, void *xdata)
554 struct print_one_inferior_data *top_data = xdata;
555 struct ui_out *uiout = current_uiout;
557 if (VEC_empty (int, top_data->inferiors)
558 || bsearch (&(inferior->pid), VEC_address (int, top_data->inferiors),
559 VEC_length (int, top_data->inferiors), sizeof (int),
560 compare_positive_ints))
562 struct collect_cores_data data;
563 struct cleanup *back_to
564 = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
566 ui_out_field_fmt (uiout, "id", "i%d", inferior->num);
567 ui_out_field_string (uiout, "type", "process");
568 if (inferior->pid != 0)
569 ui_out_field_int (uiout, "pid", inferior->pid);
571 if (inferior->pspace->ebfd)
573 ui_out_field_string (uiout, "executable",
574 bfd_get_filename (inferior->pspace->ebfd));
578 if (inferior->pid != 0)
580 data.pid = inferior->pid;
581 iterate_over_threads (collect_cores, &data);
584 if (!VEC_empty (int, data.cores))
587 struct cleanup *back_to_2 =
588 make_cleanup_ui_out_list_begin_end (uiout, "cores");
590 qsort (VEC_address (int, data.cores),
591 VEC_length (int, data.cores), sizeof (int),
592 compare_positive_ints);
594 b = VEC_address (int, data.cores);
595 e = b + VEC_length (int, data.cores);
599 ui_out_field_int (uiout, NULL, *b);
601 do_cleanups (back_to_2);
604 if (top_data->recurse)
605 print_thread_info (uiout, NULL, inferior->pid);
607 do_cleanups (back_to);
613 /* Output a field named 'cores' with a list as the value. The
614 elements of the list are obtained by splitting 'cores' on
618 output_cores (struct ui_out *uiout, const char *field_name, const char *xcores)
620 struct cleanup *back_to = make_cleanup_ui_out_list_begin_end (uiout,
622 char *cores = xstrdup (xcores);
625 make_cleanup (xfree, cores);
627 for (p = strtok (p, ","); p; p = strtok (NULL, ","))
628 ui_out_field_string (uiout, NULL, p);
630 do_cleanups (back_to);
634 free_vector_of_ints (void *xvector)
636 VEC (int) **vector = xvector;
638 VEC_free (int, *vector);
642 do_nothing (splay_tree_key k)
647 free_vector_of_osdata_items (splay_tree_value xvalue)
649 VEC (osdata_item_s) *value = (VEC (osdata_item_s) *) xvalue;
651 /* We don't free the items itself, it will be done separately. */
652 VEC_free (osdata_item_s, value);
656 splay_tree_int_comparator (splay_tree_key xa, splay_tree_key xb)
665 free_splay_tree (void *xt)
668 splay_tree_delete (t);
672 list_available_thread_groups (VEC (int) *ids, int recurse)
675 struct osdata_item *item;
677 struct ui_out *uiout = current_uiout;
679 /* This keeps a map from integer (pid) to VEC (struct osdata_item *)*
680 The vector contains information about all threads for the given pid.
681 This is assigned an initial value to avoid "may be used uninitialized"
683 splay_tree tree = NULL;
685 /* get_osdata will throw if it cannot return data. */
686 data = get_osdata ("processes");
687 make_cleanup_osdata_free (data);
691 struct osdata *threads = get_osdata ("threads");
693 make_cleanup_osdata_free (threads);
694 tree = splay_tree_new (splay_tree_int_comparator,
696 free_vector_of_osdata_items);
697 make_cleanup (free_splay_tree, tree);
700 VEC_iterate (osdata_item_s, threads->items,
704 const char *pid = get_osdata_column (item, "pid");
705 int pid_i = strtoul (pid, NULL, 0);
706 VEC (osdata_item_s) *vec = 0;
708 splay_tree_node n = splay_tree_lookup (tree, pid_i);
711 VEC_safe_push (osdata_item_s, vec, item);
712 splay_tree_insert (tree, pid_i, (splay_tree_value)vec);
716 vec = (VEC (osdata_item_s) *) n->value;
717 VEC_safe_push (osdata_item_s, vec, item);
718 n->value = (splay_tree_value) vec;
723 make_cleanup_ui_out_list_begin_end (uiout, "groups");
726 VEC_iterate (osdata_item_s, data->items,
730 struct cleanup *back_to;
732 const char *pid = get_osdata_column (item, "pid");
733 const char *cmd = get_osdata_column (item, "command");
734 const char *user = get_osdata_column (item, "user");
735 const char *cores = get_osdata_column (item, "cores");
737 int pid_i = strtoul (pid, NULL, 0);
739 /* At present, the target will return all available processes
740 and if information about specific ones was required, we filter
741 undesired processes here. */
742 if (ids && bsearch (&pid_i, VEC_address (int, ids),
743 VEC_length (int, ids),
744 sizeof (int), compare_positive_ints) == NULL)
748 back_to = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
750 ui_out_field_fmt (uiout, "id", "%s", pid);
751 ui_out_field_string (uiout, "type", "process");
753 ui_out_field_string (uiout, "description", cmd);
755 ui_out_field_string (uiout, "user", user);
757 output_cores (uiout, "cores", cores);
761 splay_tree_node n = splay_tree_lookup (tree, pid_i);
764 VEC (osdata_item_s) *children = (VEC (osdata_item_s) *) n->value;
765 struct osdata_item *child;
768 make_cleanup_ui_out_list_begin_end (uiout, "threads");
771 VEC_iterate (osdata_item_s, children, ix_child, child);
774 struct cleanup *back_to_2 =
775 make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
776 const char *tid = get_osdata_column (child, "tid");
777 const char *tcore = get_osdata_column (child, "core");
779 ui_out_field_string (uiout, "id", tid);
781 ui_out_field_string (uiout, "core", tcore);
783 do_cleanups (back_to_2);
788 do_cleanups (back_to);
793 mi_cmd_list_thread_groups (char *command, char **argv, int argc)
795 struct ui_out *uiout = current_uiout;
796 struct cleanup *back_to;
803 AVAILABLE_OPT, RECURSE_OPT
805 static const struct mi_opt opts[] =
807 {"-available", AVAILABLE_OPT, 0},
808 {"-recurse", RECURSE_OPT, 1},
817 int opt = mi_getopt ("-list-thread-groups", argc, argv, opts,
822 switch ((enum opt) opt)
828 if (strcmp (oarg, "0") == 0)
830 else if (strcmp (oarg, "1") == 0)
833 error (_("only '0' and '1' are valid values "
834 "for the '--recurse' option"));
839 for (; oind < argc; ++oind)
844 if (*(argv[oind]) != 'i')
845 error (_("invalid syntax of group id '%s'"), argv[oind]);
847 inf = strtoul (argv[oind] + 1, &end, 0);
850 error (_("invalid syntax of group id '%s'"), argv[oind]);
851 VEC_safe_push (int, ids, inf);
853 if (VEC_length (int, ids) > 1)
854 qsort (VEC_address (int, ids),
855 VEC_length (int, ids),
856 sizeof (int), compare_positive_ints);
858 back_to = make_cleanup (free_vector_of_ints, &ids);
862 list_available_thread_groups (ids, recurse);
864 else if (VEC_length (int, ids) == 1)
866 /* Local thread groups, single id. */
867 int id = *VEC_address (int, ids);
868 struct inferior *inf = find_inferior_id (id);
871 error (_("Non-existent thread group id '%d'"), id);
873 print_thread_info (uiout, NULL, inf->pid);
877 struct print_one_inferior_data data;
879 data.recurse = recurse;
880 data.inferiors = ids;
882 /* Local thread groups. Either no explicit ids -- and we
883 print everything, or several explicit ids. In both cases,
884 we print more than one group, and have to use 'groups'
885 as the top-level element. */
886 make_cleanup_ui_out_list_begin_end (uiout, "groups");
887 update_thread_list ();
888 iterate_over_inferiors (print_one_inferior, &data);
891 do_cleanups (back_to);
895 mi_cmd_data_list_register_names (char *command, char **argv, int argc)
897 struct gdbarch *gdbarch;
898 struct ui_out *uiout = current_uiout;
901 struct cleanup *cleanup;
903 /* Note that the test for a valid register must include checking the
904 gdbarch_register_name because gdbarch_num_regs may be allocated
905 for the union of the register sets within a family of related
906 processors. In this case, some entries of gdbarch_register_name
907 will change depending upon the particular processor being
910 gdbarch = get_current_arch ();
911 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
913 cleanup = make_cleanup_ui_out_list_begin_end (uiout, "register-names");
915 if (argc == 0) /* No args, just do all the regs. */
921 if (gdbarch_register_name (gdbarch, regnum) == NULL
922 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
923 ui_out_field_string (uiout, NULL, "");
925 ui_out_field_string (uiout, NULL,
926 gdbarch_register_name (gdbarch, regnum));
930 /* Else, list of register #s, just do listed regs. */
931 for (i = 0; i < argc; i++)
933 regnum = atoi (argv[i]);
934 if (regnum < 0 || regnum >= numregs)
935 error (_("bad register number"));
937 if (gdbarch_register_name (gdbarch, regnum) == NULL
938 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
939 ui_out_field_string (uiout, NULL, "");
941 ui_out_field_string (uiout, NULL,
942 gdbarch_register_name (gdbarch, regnum));
944 do_cleanups (cleanup);
948 mi_cmd_data_list_changed_registers (char *command, char **argv, int argc)
950 static struct regcache *this_regs = NULL;
951 struct ui_out *uiout = current_uiout;
952 struct regcache *prev_regs;
953 struct gdbarch *gdbarch;
954 int regnum, numregs, changed;
956 struct cleanup *cleanup;
958 /* The last time we visited this function, the current frame's
959 register contents were saved in THIS_REGS. Move THIS_REGS over
960 to PREV_REGS, and refresh THIS_REGS with the now-current register
963 prev_regs = this_regs;
964 this_regs = frame_save_as_regcache (get_selected_frame (NULL));
965 cleanup = make_cleanup_regcache_xfree (prev_regs);
967 /* Note that the test for a valid register must include checking the
968 gdbarch_register_name because gdbarch_num_regs may be allocated
969 for the union of the register sets within a family of related
970 processors. In this case, some entries of gdbarch_register_name
971 will change depending upon the particular processor being
974 gdbarch = get_regcache_arch (this_regs);
975 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
977 make_cleanup_ui_out_list_begin_end (uiout, "changed-registers");
981 /* No args, just do all the regs. */
986 if (gdbarch_register_name (gdbarch, regnum) == NULL
987 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
989 changed = register_changed_p (regnum, prev_regs, this_regs);
991 error (_("-data-list-changed-registers: "
992 "Unable to read register contents."));
994 ui_out_field_int (uiout, NULL, regnum);
998 /* Else, list of register #s, just do listed regs. */
999 for (i = 0; i < argc; i++)
1001 regnum = atoi (argv[i]);
1005 && gdbarch_register_name (gdbarch, regnum) != NULL
1006 && *gdbarch_register_name (gdbarch, regnum) != '\000')
1008 changed = register_changed_p (regnum, prev_regs, this_regs);
1010 error (_("-data-list-changed-registers: "
1011 "Unable to read register contents."));
1013 ui_out_field_int (uiout, NULL, regnum);
1016 error (_("bad register number"));
1018 do_cleanups (cleanup);
1022 register_changed_p (int regnum, struct regcache *prev_regs,
1023 struct regcache *this_regs)
1025 struct gdbarch *gdbarch = get_regcache_arch (this_regs);
1026 gdb_byte prev_buffer[MAX_REGISTER_SIZE];
1027 gdb_byte this_buffer[MAX_REGISTER_SIZE];
1028 enum register_status prev_status;
1029 enum register_status this_status;
1031 /* First time through or after gdbarch change consider all registers
1033 if (!prev_regs || get_regcache_arch (prev_regs) != gdbarch)
1036 /* Get register contents and compare. */
1037 prev_status = regcache_cooked_read (prev_regs, regnum, prev_buffer);
1038 this_status = regcache_cooked_read (this_regs, regnum, this_buffer);
1040 if (this_status != prev_status)
1042 else if (this_status == REG_VALID)
1043 return memcmp (prev_buffer, this_buffer,
1044 register_size (gdbarch, regnum)) != 0;
1049 /* Return a list of register number and value pairs. The valid
1050 arguments expected are: a letter indicating the format in which to
1051 display the registers contents. This can be one of: x
1052 (hexadecimal), d (decimal), N (natural), t (binary), o (octal), r
1053 (raw). After the format argument there can be a sequence of
1054 numbers, indicating which registers to fetch the content of. If
1055 the format is the only argument, a list of all the registers with
1056 their values is returned. */
1059 mi_cmd_data_list_register_values (char *command, char **argv, int argc)
1061 struct ui_out *uiout = current_uiout;
1062 struct frame_info *frame;
1063 struct gdbarch *gdbarch;
1064 int regnum, numregs, format;
1066 struct cleanup *list_cleanup, *tuple_cleanup;
1068 /* Note that the test for a valid register must include checking the
1069 gdbarch_register_name because gdbarch_num_regs may be allocated
1070 for the union of the register sets within a family of related
1071 processors. In this case, some entries of gdbarch_register_name
1072 will change depending upon the particular processor being
1076 error (_("-data-list-register-values: Usage: "
1077 "-data-list-register-values <format> [<regnum1>...<regnumN>]"));
1079 format = (int) argv[0][0];
1081 frame = get_selected_frame (NULL);
1082 gdbarch = get_frame_arch (frame);
1083 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
1085 list_cleanup = make_cleanup_ui_out_list_begin_end (uiout, "register-values");
1089 /* No args, beside the format: do all the regs. */
1094 if (gdbarch_register_name (gdbarch, regnum) == NULL
1095 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
1097 tuple_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1098 ui_out_field_int (uiout, "number", regnum);
1099 get_register (frame, regnum, format);
1100 do_cleanups (tuple_cleanup);
1104 /* Else, list of register #s, just do listed regs. */
1105 for (i = 1; i < argc; i++)
1107 regnum = atoi (argv[i]);
1111 && gdbarch_register_name (gdbarch, regnum) != NULL
1112 && *gdbarch_register_name (gdbarch, regnum) != '\000')
1114 tuple_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1115 ui_out_field_int (uiout, "number", regnum);
1116 get_register (frame, regnum, format);
1117 do_cleanups (tuple_cleanup);
1120 error (_("bad register number"));
1122 do_cleanups (list_cleanup);
1125 /* Output one register's contents in the desired format. */
1128 get_register (struct frame_info *frame, int regnum, int format)
1130 struct gdbarch *gdbarch = get_frame_arch (frame);
1131 struct ui_out *uiout = current_uiout;
1133 enum lval_type lval;
1134 struct ui_stream *stb;
1137 stb = ui_out_stream_new (uiout);
1142 val = get_frame_register_value (frame, regnum);
1144 if (value_optimized_out (val))
1145 error (_("Optimized out"));
1150 char *ptr, buf[1024];
1151 const gdb_byte *valaddr = value_contents_for_printing (val);
1155 for (j = 0; j < register_size (gdbarch, regnum); j++)
1157 int idx = gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG ?
1158 j : register_size (gdbarch, regnum) - 1 - j;
1160 sprintf (ptr, "%02x", (unsigned char) valaddr[idx]);
1163 ui_out_field_string (uiout, "value", buf);
1167 struct value_print_options opts;
1169 get_formatted_print_options (&opts, format);
1171 val_print (value_type (val),
1172 value_contents_for_printing (val),
1173 value_embedded_offset (val), 0,
1174 stb->stream, 0, val, &opts, current_language);
1175 ui_out_field_stream (uiout, "value", stb);
1176 ui_out_stream_delete (stb);
1180 /* Write given values into registers. The registers and values are
1181 given as pairs. The corresponding MI command is
1182 -data-write-register-values <format>
1183 [<regnum1> <value1>...<regnumN> <valueN>] */
1185 mi_cmd_data_write_register_values (char *command, char **argv, int argc)
1187 struct regcache *regcache;
1188 struct gdbarch *gdbarch;
1192 /* Note that the test for a valid register must include checking the
1193 gdbarch_register_name because gdbarch_num_regs may be allocated
1194 for the union of the register sets within a family of related
1195 processors. In this case, some entries of gdbarch_register_name
1196 will change depending upon the particular processor being
1199 regcache = get_current_regcache ();
1200 gdbarch = get_regcache_arch (regcache);
1201 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
1204 error (_("-data-write-register-values: Usage: -data-write-register-"
1205 "values <format> [<regnum1> <value1>...<regnumN> <valueN>]"));
1207 format = (int) argv[0][0];
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 = NULL;
1250 struct ui_stream *stb = NULL;
1251 struct value_print_options opts;
1252 struct ui_out *uiout = current_uiout;
1254 stb = ui_out_stream_new (uiout);
1258 ui_out_stream_delete (stb);
1259 error (_("-data-evaluate-expression: "
1260 "Usage: -data-evaluate-expression expression"));
1263 expr = parse_expression (argv[0]);
1265 old_chain = make_cleanup (free_current_contents, &expr);
1267 val = evaluate_expression (expr);
1269 /* Print the result of the expression evaluation. */
1270 get_user_print_options (&opts);
1272 common_val_print (val, stb->stream, 0, &opts, current_language);
1274 ui_out_field_stream (uiout, "value", stb);
1275 ui_out_stream_delete (stb);
1277 do_cleanups (old_chain);
1280 /* This is the -data-read-memory command.
1282 ADDR: start address of data to be dumped.
1283 WORD-FORMAT: a char indicating format for the ``word''. See
1285 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
1286 NR_ROW: Number of rows.
1287 NR_COL: The number of colums (words per row).
1288 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
1289 ASCHAR for unprintable characters.
1291 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
1292 displayes them. Returns:
1294 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
1297 The number of bytes read is SIZE*ROW*COL. */
1300 mi_cmd_data_read_memory (char *command, char **argv, int argc)
1302 struct gdbarch *gdbarch = get_current_arch ();
1303 struct ui_out *uiout = current_uiout;
1304 struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
1306 long total_bytes, nr_cols, nr_rows;
1308 struct type *word_type;
1321 static const struct mi_opt opts[] =
1323 {"o", OFFSET_OPT, 1},
1329 int opt = mi_getopt ("-data-read-memory", argc, argv, opts,
1334 switch ((enum opt) opt)
1337 offset = atol (oarg);
1344 if (argc < 5 || argc > 6)
1345 error (_("-data-read-memory: Usage: "
1346 "ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR]."));
1348 /* Extract all the arguments. */
1350 /* Start address of the memory dump. */
1351 addr = parse_and_eval_address (argv[0]) + offset;
1352 /* The format character to use when displaying a memory word. See
1353 the ``x'' command. */
1354 word_format = argv[1][0];
1355 /* The size of the memory word. */
1356 word_size = atol (argv[2]);
1360 word_type = builtin_type (gdbarch)->builtin_int8;
1364 word_type = builtin_type (gdbarch)->builtin_int16;
1368 word_type = builtin_type (gdbarch)->builtin_int32;
1372 word_type = builtin_type (gdbarch)->builtin_int64;
1376 word_type = builtin_type (gdbarch)->builtin_int8;
1379 /* The number of rows. */
1380 nr_rows = atol (argv[3]);
1382 error (_("-data-read-memory: invalid number of rows."));
1384 /* Number of bytes per row. */
1385 nr_cols = atol (argv[4]);
1387 error (_("-data-read-memory: invalid number of columns."));
1389 /* The un-printable character when printing ascii. */
1395 /* Create a buffer and read it in. */
1396 total_bytes = word_size * nr_rows * nr_cols;
1397 mbuf = xcalloc (total_bytes, 1);
1398 make_cleanup (xfree, mbuf);
1400 /* Dispatch memory reads to the topmost target, not the flattened
1402 nr_bytes = target_read (current_target.beneath,
1403 TARGET_OBJECT_MEMORY, NULL, mbuf,
1406 error (_("Unable to read memory."));
1408 /* Output the header information. */
1409 ui_out_field_core_addr (uiout, "addr", gdbarch, addr);
1410 ui_out_field_int (uiout, "nr-bytes", nr_bytes);
1411 ui_out_field_int (uiout, "total-bytes", total_bytes);
1412 ui_out_field_core_addr (uiout, "next-row",
1413 gdbarch, addr + word_size * nr_cols);
1414 ui_out_field_core_addr (uiout, "prev-row",
1415 gdbarch, addr - word_size * nr_cols);
1416 ui_out_field_core_addr (uiout, "next-page", gdbarch, addr + total_bytes);
1417 ui_out_field_core_addr (uiout, "prev-page", gdbarch, addr - total_bytes);
1419 /* Build the result as a two dimentional table. */
1421 struct ui_stream *stream = ui_out_stream_new (uiout);
1422 struct cleanup *cleanup_list_memory;
1426 cleanup_list_memory = 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->stream);
1454 print_scalar_formatted (mbuf + col_byte, word_type, &opts,
1455 word_asize, stream->stream);
1456 ui_out_field_stream (uiout, NULL, stream);
1459 do_cleanups (cleanup_list_data);
1464 ui_file_rewind (stream->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->stream);
1470 else if (mbuf[byte] < 32 || mbuf[byte] > 126)
1471 fputc_unfiltered (aschar, stream->stream);
1473 fputc_unfiltered (mbuf[byte], stream->stream);
1475 ui_out_field_stream (uiout, "ascii", stream);
1477 do_cleanups (cleanup_tuple);
1479 ui_out_stream_delete (stream);
1480 do_cleanups (cleanup_list_memory);
1482 do_cleanups (cleanups);
1486 mi_cmd_data_read_memory_bytes (char *command, char **argv, int argc)
1488 struct gdbarch *gdbarch = get_current_arch ();
1489 struct ui_out *uiout = current_uiout;
1490 struct cleanup *cleanups;
1493 memory_read_result_s *read_result;
1495 VEC(memory_read_result_s) *result;
1503 static const struct mi_opt opts[] =
1505 {"o", OFFSET_OPT, 1},
1511 int opt = mi_getopt ("-data-read-memory-bytes", argc, argv, opts,
1515 switch ((enum opt) opt)
1518 offset = atol (oarg);
1526 error (_("Usage: [ -o OFFSET ] ADDR LENGTH."));
1528 addr = parse_and_eval_address (argv[0]) + offset;
1529 length = atol (argv[1]);
1531 result = read_memory_robust (current_target.beneath, addr, length);
1533 cleanups = make_cleanup (free_memory_read_result_vector, result);
1535 if (VEC_length (memory_read_result_s, result) == 0)
1536 error (_("Unable to read memory."));
1538 make_cleanup_ui_out_list_begin_end (uiout, "memory");
1540 VEC_iterate (memory_read_result_s, result, ix, read_result);
1543 struct cleanup *t = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1547 ui_out_field_core_addr (uiout, "begin", gdbarch, read_result->begin);
1548 ui_out_field_core_addr (uiout, "offset", gdbarch, read_result->begin
1550 ui_out_field_core_addr (uiout, "end", gdbarch, read_result->end);
1552 data = xmalloc ((read_result->end - read_result->begin) * 2 + 1);
1554 for (i = 0, p = data;
1555 i < (read_result->end - read_result->begin);
1558 sprintf (p, "%02x", read_result->data[i]);
1560 ui_out_field_string (uiout, "contents", data);
1564 do_cleanups (cleanups);
1567 /* Implementation of the -data-write_memory command.
1569 COLUMN_OFFSET: optional argument. Must be preceded by '-o'. The
1570 offset from the beginning of the memory grid row where the cell to
1572 ADDR: start address of the row in the memory grid where the memory
1573 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
1574 the location to write to.
1575 FORMAT: a char indicating format for the ``word''. See
1577 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
1578 VALUE: value to be written into the memory address.
1580 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1585 mi_cmd_data_write_memory (char *command, char **argv, int argc)
1587 struct gdbarch *gdbarch = get_current_arch ();
1588 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1592 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1593 enough when using a compiler other than GCC. */
1596 struct cleanup *old_chain;
1604 static const struct mi_opt opts[] =
1606 {"o", OFFSET_OPT, 1},
1612 int opt = mi_getopt ("-data-write-memory", argc, argv, opts,
1617 switch ((enum opt) opt)
1620 offset = atol (oarg);
1628 error (_("-data-write-memory: Usage: "
1629 "[-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE."));
1631 /* Extract all the arguments. */
1632 /* Start address of the memory dump. */
1633 addr = parse_and_eval_address (argv[0]);
1634 /* The format character to use when displaying a memory word. See
1635 the ``x'' command. */
1636 word_format = argv[1][0];
1637 /* The size of the memory word. */
1638 word_size = atol (argv[2]);
1640 /* Calculate the real address of the write destination. */
1641 addr += (offset * word_size);
1643 /* Get the value as a number. */
1644 value = parse_and_eval_address (argv[3]);
1645 /* Get the value into an array. */
1646 buffer = xmalloc (word_size);
1647 old_chain = make_cleanup (xfree, buffer);
1648 store_signed_integer (buffer, word_size, byte_order, value);
1649 /* Write it down to memory. */
1650 write_memory (addr, buffer, word_size);
1651 /* Free the buffer. */
1652 do_cleanups (old_chain);
1655 /* Implementation of the -data-write-memory-bytes command.
1658 DATA: string of bytes to write at that address. */
1661 mi_cmd_data_write_memory_bytes (char *command, char **argv, int argc)
1667 struct cleanup *back_to;
1670 error (_("Usage: ADDR DATA."));
1672 addr = parse_and_eval_address (argv[0]);
1674 len = strlen (cdata)/2;
1676 data = xmalloc (len);
1677 back_to = make_cleanup (xfree, data);
1679 for (i = 0; i < len; ++i)
1682 sscanf (cdata + i * 2, "%02x", &x);
1683 data[i] = (gdb_byte) x;
1686 r = target_write_memory (addr, data, len);
1688 error (_("Could not write memory"));
1690 do_cleanups (back_to);
1694 mi_cmd_enable_timings (char *command, char **argv, int argc)
1700 if (strcmp (argv[0], "yes") == 0)
1702 else if (strcmp (argv[0], "no") == 0)
1713 error (_("-enable-timings: Usage: %s {yes|no}"), command);
1717 mi_cmd_list_features (char *command, char **argv, int argc)
1721 struct cleanup *cleanup = NULL;
1722 struct ui_out *uiout = current_uiout;
1724 cleanup = make_cleanup_ui_out_list_begin_end (uiout, "features");
1725 ui_out_field_string (uiout, NULL, "frozen-varobjs");
1726 ui_out_field_string (uiout, NULL, "pending-breakpoints");
1727 ui_out_field_string (uiout, NULL, "thread-info");
1728 ui_out_field_string (uiout, NULL, "data-read-memory-bytes");
1729 ui_out_field_string (uiout, NULL, "breakpoint-notifications");
1730 ui_out_field_string (uiout, NULL, "ada-task-info");
1733 ui_out_field_string (uiout, NULL, "python");
1736 do_cleanups (cleanup);
1740 error (_("-list-features should be passed no arguments"));
1744 mi_cmd_list_target_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 if (target_can_async_p ())
1753 ui_out_field_string (uiout, NULL, "async");
1754 if (target_can_execute_reverse)
1755 ui_out_field_string (uiout, NULL, "reverse");
1757 do_cleanups (cleanup);
1761 error (_("-list-target-features should be passed no arguments"));
1765 mi_cmd_add_inferior (char *command, char **argv, int argc)
1767 struct inferior *inf;
1770 error (_("-add-inferior should be passed no arguments"));
1772 inf = add_inferior_with_spaces ();
1774 ui_out_field_fmt (current_uiout, "inferior", "i%d", inf->num);
1777 /* Callback used to find the first inferior other than the current
1781 get_other_inferior (struct inferior *inf, void *arg)
1783 if (inf == current_inferior ())
1790 mi_cmd_remove_inferior (char *command, char **argv, int argc)
1793 struct inferior *inf;
1796 error (_("-remove-inferior should be passed a single argument"));
1798 if (sscanf (argv[0], "i%d", &id) != 1)
1799 error (_("the thread group id is syntactically invalid"));
1801 inf = find_inferior_id (id);
1803 error (_("the specified thread group does not exist"));
1806 error (_("cannot remove an active inferior"));
1808 if (inf == current_inferior ())
1810 struct thread_info *tp = 0;
1811 struct inferior *new_inferior
1812 = iterate_over_inferiors (get_other_inferior, NULL);
1814 if (new_inferior == NULL)
1815 error (_("Cannot remove last inferior"));
1817 set_current_inferior (new_inferior);
1818 if (new_inferior->pid != 0)
1819 tp = any_thread_of_process (new_inferior->pid);
1820 switch_to_thread (tp ? tp->ptid : null_ptid);
1821 set_current_program_space (new_inferior->pspace);
1824 delete_inferior_1 (inf, 1 /* silent */);
1829 /* Execute a command within a safe environment.
1830 Return <0 for error; >=0 for ok.
1832 args->action will tell mi_execute_command what action
1833 to perfrom after the given command has executed (display/suppress
1834 prompt, display error). */
1837 captured_mi_execute_command (struct ui_out *uiout, struct mi_parse *context)
1839 struct cleanup *cleanup;
1842 current_command_ts = context->cmd_start;
1844 current_token = xstrdup (context->token);
1845 cleanup = make_cleanup (free_current_contents, ¤t_token);
1847 running_result_record_printed = 0;
1849 switch (context->op)
1852 /* A MI command was read from the input stream. */
1854 /* FIXME: gdb_???? */
1855 fprintf_unfiltered (raw_stdout, " token=`%s' command=`%s' args=`%s'\n",
1856 context->token, context->command, context->args);
1858 mi_cmd_execute (context);
1860 /* Print the result if there were no errors.
1862 Remember that on the way out of executing a command, you have
1863 to directly use the mi_interp's uiout, since the command
1864 could have reset the interpreter, in which case the current
1865 uiout will most likely crash in the mi_out_* routines. */
1866 if (!running_result_record_printed)
1868 fputs_unfiltered (context->token, raw_stdout);
1869 /* There's no particularly good reason why target-connect results
1870 in not ^done. Should kill ^connected for MI3. */
1871 fputs_unfiltered (strcmp (context->command, "target-select") == 0
1872 ? "^connected" : "^done", raw_stdout);
1873 mi_out_put (uiout, raw_stdout);
1874 mi_out_rewind (uiout);
1875 mi_print_timing_maybe ();
1876 fputs_unfiltered ("\n", raw_stdout);
1879 /* The command does not want anything to be printed. In that
1880 case, the command probably should not have written anything
1881 to uiout, but in case it has written something, discard it. */
1882 mi_out_rewind (uiout);
1889 /* A CLI command was read from the input stream. */
1890 /* This "feature" will be removed as soon as we have a
1891 complete set of mi commands. */
1892 /* Echo the command on the console. */
1893 fprintf_unfiltered (gdb_stdlog, "%s\n", context->command);
1894 /* Call the "console" interpreter. */
1895 argv[0] = "console";
1896 argv[1] = context->command;
1897 mi_cmd_interpreter_exec ("-interpreter-exec", argv, 2);
1899 /* If we changed interpreters, DON'T print out anything. */
1900 if (current_interp_named_p (INTERP_MI)
1901 || current_interp_named_p (INTERP_MI1)
1902 || current_interp_named_p (INTERP_MI2)
1903 || current_interp_named_p (INTERP_MI3))
1905 if (!running_result_record_printed)
1907 fputs_unfiltered (context->token, raw_stdout);
1908 fputs_unfiltered ("^done", raw_stdout);
1909 mi_out_put (uiout, raw_stdout);
1910 mi_out_rewind (uiout);
1911 mi_print_timing_maybe ();
1912 fputs_unfiltered ("\n", raw_stdout);
1915 mi_out_rewind (uiout);
1921 do_cleanups (cleanup);
1924 /* Print a gdb exception to the MI output stream. */
1927 mi_print_exception (const char *token, struct gdb_exception exception)
1929 fputs_unfiltered (token, raw_stdout);
1930 fputs_unfiltered ("^error,msg=\"", raw_stdout);
1931 if (exception.message == NULL)
1932 fputs_unfiltered ("unknown error", raw_stdout);
1934 fputstr_unfiltered (exception.message, '"', raw_stdout);
1935 fputs_unfiltered ("\"\n", raw_stdout);
1939 mi_execute_command (char *cmd, int from_tty)
1942 struct mi_parse *command = NULL;
1943 volatile struct gdb_exception exception;
1945 /* This is to handle EOF (^D). We just quit gdb. */
1946 /* FIXME: we should call some API function here. */
1948 quit_force (NULL, from_tty);
1950 target_log_command (cmd);
1952 TRY_CATCH (exception, RETURN_MASK_ALL)
1954 command = mi_parse (cmd, &token);
1956 if (exception.reason < 0)
1958 mi_print_exception (token, exception);
1963 volatile struct gdb_exception result;
1964 ptid_t previous_ptid = inferior_ptid;
1966 command->token = token;
1970 command->cmd_start = (struct mi_timestamp *)
1971 xmalloc (sizeof (struct mi_timestamp));
1972 timestamp (command->cmd_start);
1975 TRY_CATCH (result, RETURN_MASK_ALL)
1977 captured_mi_execute_command (current_uiout, command);
1979 if (result.reason < 0)
1981 /* The command execution failed and error() was called
1983 mi_print_exception (command->token, result);
1984 mi_out_rewind (current_uiout);
1987 bpstat_do_actions ();
1989 if (/* The notifications are only output when the top-level
1990 interpreter (specified on the command line) is MI. */
1991 ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ()))
1992 /* Don't try report anything if there are no threads --
1993 the program is dead. */
1994 && thread_count () != 0
1995 /* -thread-select explicitly changes thread. If frontend uses that
1996 internally, we don't want to emit =thread-selected, since
1997 =thread-selected is supposed to indicate user's intentions. */
1998 && strcmp (command->command, "thread-select") != 0)
2000 struct mi_interp *mi = top_level_interpreter_data ();
2001 int report_change = 0;
2003 if (command->thread == -1)
2005 report_change = (!ptid_equal (previous_ptid, null_ptid)
2006 && !ptid_equal (inferior_ptid, previous_ptid)
2007 && !ptid_equal (inferior_ptid, null_ptid));
2009 else if (!ptid_equal (inferior_ptid, null_ptid))
2011 struct thread_info *ti = inferior_thread ();
2013 report_change = (ti->num != command->thread);
2018 struct thread_info *ti = inferior_thread ();
2020 target_terminal_ours ();
2021 fprintf_unfiltered (mi->event_channel,
2022 "thread-selected,id=\"%d\"",
2024 gdb_flush (mi->event_channel);
2028 mi_parse_free (command);
2031 fputs_unfiltered ("(gdb) \n", raw_stdout);
2032 gdb_flush (raw_stdout);
2036 mi_cmd_execute (struct mi_parse *parse)
2038 struct cleanup *cleanup;
2040 cleanup = prepare_execute_command ();
2042 if (parse->all && parse->thread_group != -1)
2043 error (_("Cannot specify --thread-group together with --all"));
2045 if (parse->all && parse->thread != -1)
2046 error (_("Cannot specify --thread together with --all"));
2048 if (parse->thread_group != -1 && parse->thread != -1)
2049 error (_("Cannot specify --thread together with --thread-group"));
2051 if (parse->frame != -1 && parse->thread == -1)
2052 error (_("Cannot specify --frame without --thread"));
2054 if (parse->thread_group != -1)
2056 struct inferior *inf = find_inferior_id (parse->thread_group);
2057 struct thread_info *tp = 0;
2060 error (_("Invalid thread group for the --thread-group option"));
2062 set_current_inferior (inf);
2063 /* This behaviour means that if --thread-group option identifies
2064 an inferior with multiple threads, then a random one will be
2065 picked. This is not a problem -- frontend should always
2066 provide --thread if it wishes to operate on a specific
2069 tp = any_thread_of_process (inf->pid);
2070 switch_to_thread (tp ? tp->ptid : null_ptid);
2071 set_current_program_space (inf->pspace);
2074 if (parse->thread != -1)
2076 struct thread_info *tp = find_thread_id (parse->thread);
2079 error (_("Invalid thread id: %d"), parse->thread);
2081 if (is_exited (tp->ptid))
2082 error (_("Thread id: %d has terminated"), parse->thread);
2084 switch_to_thread (tp->ptid);
2087 if (parse->frame != -1)
2089 struct frame_info *fid;
2090 int frame = parse->frame;
2092 fid = find_relative_frame (get_current_frame (), &frame);
2094 /* find_relative_frame was successful */
2097 error (_("Invalid frame id: %d"), frame);
2100 current_context = parse;
2102 if (strncmp (parse->command, "break-", sizeof ("break-") - 1 ) == 0)
2104 make_cleanup_restore_integer (&mi_suppress_breakpoint_notifications);
2105 mi_suppress_breakpoint_notifications = 1;
2108 if (parse->cmd->argv_func != NULL)
2110 parse->cmd->argv_func (parse->command, parse->argv, parse->argc);
2112 else if (parse->cmd->cli.cmd != 0)
2114 /* FIXME: DELETE THIS. */
2115 /* The operation is still implemented by a cli command. */
2116 /* Must be a synchronous one. */
2117 mi_execute_cli_command (parse->cmd->cli.cmd, parse->cmd->cli.args_p,
2122 /* FIXME: DELETE THIS. */
2123 struct ui_file *stb;
2125 stb = mem_fileopen ();
2127 fputs_unfiltered ("Undefined mi command: ", stb);
2128 fputstr_unfiltered (parse->command, '"', stb);
2129 fputs_unfiltered (" (missing implementation)", stb);
2131 make_cleanup_ui_file_delete (stb);
2134 do_cleanups (cleanup);
2137 /* FIXME: This is just a hack so we can get some extra commands going.
2138 We don't want to channel things through the CLI, but call libgdb directly.
2139 Use only for synchronous commands. */
2142 mi_execute_cli_command (const char *cmd, int args_p, const char *args)
2146 struct cleanup *old_cleanups;
2150 run = xstrprintf ("%s %s", cmd, args);
2152 run = xstrdup (cmd);
2154 /* FIXME: gdb_???? */
2155 fprintf_unfiltered (gdb_stdout, "cli=%s run=%s\n",
2157 old_cleanups = make_cleanup (xfree, run);
2158 execute_command (run, 0 /* from_tty */ );
2159 do_cleanups (old_cleanups);
2165 mi_execute_async_cli_command (char *cli_command, char **argv, int argc)
2167 struct cleanup *old_cleanups;
2170 if (target_can_async_p ())
2171 run = xstrprintf ("%s %s&", cli_command, argc ? *argv : "");
2173 run = xstrprintf ("%s %s", cli_command, argc ? *argv : "");
2174 old_cleanups = make_cleanup (xfree, run);
2176 execute_command (run, 0 /* from_tty */ );
2178 /* Do this before doing any printing. It would appear that some
2179 print code leaves garbage around in the buffer. */
2180 do_cleanups (old_cleanups);
2184 mi_load_progress (const char *section_name,
2185 unsigned long sent_so_far,
2186 unsigned long total_section,
2187 unsigned long total_sent,
2188 unsigned long grand_total)
2190 struct timeval time_now, delta, update_threshold;
2191 static struct timeval last_update;
2192 static char *previous_sect_name = NULL;
2194 struct ui_out *saved_uiout;
2195 struct ui_out *uiout;
2197 /* This function is called through deprecated_show_load_progress
2198 which means uiout may not be correct. Fix it for the duration
2199 of this function. */
2200 saved_uiout = current_uiout;
2202 if (current_interp_named_p (INTERP_MI)
2203 || current_interp_named_p (INTERP_MI2))
2204 current_uiout = mi_out_new (2);
2205 else if (current_interp_named_p (INTERP_MI1))
2206 current_uiout = mi_out_new (1);
2207 else if (current_interp_named_p (INTERP_MI3))
2208 current_uiout = mi_out_new (3);
2212 uiout = current_uiout;
2214 update_threshold.tv_sec = 0;
2215 update_threshold.tv_usec = 500000;
2216 gettimeofday (&time_now, NULL);
2218 delta.tv_usec = time_now.tv_usec - last_update.tv_usec;
2219 delta.tv_sec = time_now.tv_sec - last_update.tv_sec;
2221 if (delta.tv_usec < 0)
2224 delta.tv_usec += 1000000L;
2227 new_section = (previous_sect_name ?
2228 strcmp (previous_sect_name, section_name) : 1);
2231 struct cleanup *cleanup_tuple;
2233 xfree (previous_sect_name);
2234 previous_sect_name = xstrdup (section_name);
2237 fputs_unfiltered (current_token, raw_stdout);
2238 fputs_unfiltered ("+download", raw_stdout);
2239 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
2240 ui_out_field_string (uiout, "section", section_name);
2241 ui_out_field_int (uiout, "section-size", total_section);
2242 ui_out_field_int (uiout, "total-size", grand_total);
2243 do_cleanups (cleanup_tuple);
2244 mi_out_put (uiout, raw_stdout);
2245 fputs_unfiltered ("\n", raw_stdout);
2246 gdb_flush (raw_stdout);
2249 if (delta.tv_sec >= update_threshold.tv_sec &&
2250 delta.tv_usec >= update_threshold.tv_usec)
2252 struct cleanup *cleanup_tuple;
2254 last_update.tv_sec = time_now.tv_sec;
2255 last_update.tv_usec = time_now.tv_usec;
2257 fputs_unfiltered (current_token, raw_stdout);
2258 fputs_unfiltered ("+download", raw_stdout);
2259 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
2260 ui_out_field_string (uiout, "section", section_name);
2261 ui_out_field_int (uiout, "section-sent", sent_so_far);
2262 ui_out_field_int (uiout, "section-size", total_section);
2263 ui_out_field_int (uiout, "total-sent", total_sent);
2264 ui_out_field_int (uiout, "total-size", grand_total);
2265 do_cleanups (cleanup_tuple);
2266 mi_out_put (uiout, raw_stdout);
2267 fputs_unfiltered ("\n", raw_stdout);
2268 gdb_flush (raw_stdout);
2272 current_uiout = saved_uiout;
2276 timestamp (struct mi_timestamp *tv)
2278 gettimeofday (&tv->wallclock, NULL);
2279 #ifdef HAVE_GETRUSAGE
2280 getrusage (RUSAGE_SELF, &rusage);
2281 tv->utime.tv_sec = rusage.ru_utime.tv_sec;
2282 tv->utime.tv_usec = rusage.ru_utime.tv_usec;
2283 tv->stime.tv_sec = rusage.ru_stime.tv_sec;
2284 tv->stime.tv_usec = rusage.ru_stime.tv_usec;
2287 long usec = get_run_time ();
2289 tv->utime.tv_sec = usec/1000000L;
2290 tv->utime.tv_usec = usec - 1000000L*tv->utime.tv_sec;
2291 tv->stime.tv_sec = 0;
2292 tv->stime.tv_usec = 0;
2298 print_diff_now (struct mi_timestamp *start)
2300 struct mi_timestamp now;
2303 print_diff (start, &now);
2307 mi_print_timing_maybe (void)
2309 /* If the command is -enable-timing then do_timings may be true
2310 whilst current_command_ts is not initialized. */
2311 if (do_timings && current_command_ts)
2312 print_diff_now (current_command_ts);
2316 timeval_diff (struct timeval start, struct timeval end)
2318 return ((end.tv_sec - start.tv_sec) * 1000000L)
2319 + (end.tv_usec - start.tv_usec);
2323 print_diff (struct mi_timestamp *start, struct mi_timestamp *end)
2327 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
2328 timeval_diff (start->wallclock, end->wallclock) / 1000000.0,
2329 timeval_diff (start->utime, end->utime) / 1000000.0,
2330 timeval_diff (start->stime, end->stime) / 1000000.0);
2334 mi_cmd_trace_define_variable (char *command, char **argv, int argc)
2336 struct expression *expr;
2337 struct cleanup *back_to;
2338 LONGEST initval = 0;
2339 struct trace_state_variable *tsv;
2342 if (argc != 1 && argc != 2)
2343 error (_("Usage: -trace-define-variable VARIABLE [VALUE]"));
2345 expr = parse_expression (argv[0]);
2346 back_to = make_cleanup (xfree, expr);
2348 if (expr->nelts == 3 && expr->elts[0].opcode == OP_INTERNALVAR)
2350 struct internalvar *intvar = expr->elts[1].internalvar;
2353 name = internalvar_name (intvar);
2356 if (!name || *name == '\0')
2357 error (_("Invalid name of trace variable"));
2359 tsv = find_trace_state_variable (name);
2361 tsv = create_trace_state_variable (name);
2364 initval = value_as_long (parse_and_eval (argv[1]));
2366 tsv->initial_value = initval;
2368 do_cleanups (back_to);
2372 mi_cmd_trace_list_variables (char *command, char **argv, int argc)
2375 error (_("-trace-list-variables: no arguments allowed"));
2377 tvariables_info_1 ();
2381 mi_cmd_trace_find (char *command, char **argv, int argc)
2386 error (_("trace selection mode is required"));
2390 if (strcmp (mode, "none") == 0)
2392 tfind_1 (tfind_number, -1, 0, 0, 0);
2396 if (current_trace_status ()->running)
2397 error (_("May not look at trace frames while trace is running."));
2399 if (strcmp (mode, "frame-number") == 0)
2402 error (_("frame number is required"));
2403 tfind_1 (tfind_number, atoi (argv[1]), 0, 0, 0);
2405 else if (strcmp (mode, "tracepoint-number") == 0)
2408 error (_("tracepoint number is required"));
2409 tfind_1 (tfind_tp, atoi (argv[1]), 0, 0, 0);
2411 else if (strcmp (mode, "pc") == 0)
2414 error (_("PC is required"));
2415 tfind_1 (tfind_pc, 0, parse_and_eval_address (argv[1]), 0, 0);
2417 else if (strcmp (mode, "pc-inside-range") == 0)
2420 error (_("Start and end PC are required"));
2421 tfind_1 (tfind_range, 0, parse_and_eval_address (argv[1]),
2422 parse_and_eval_address (argv[2]), 0);
2424 else if (strcmp (mode, "pc-outside-range") == 0)
2427 error (_("Start and end PC are required"));
2428 tfind_1 (tfind_outside, 0, parse_and_eval_address (argv[1]),
2429 parse_and_eval_address (argv[2]), 0);
2431 else if (strcmp (mode, "line") == 0)
2433 struct symtabs_and_lines sals;
2434 struct symtab_and_line sal;
2435 static CORE_ADDR start_pc, end_pc;
2436 struct cleanup *back_to;
2439 error (_("Line is required"));
2441 sals = decode_line_spec (argv[1], DECODE_LINE_FUNFIRSTLINE);
2442 back_to = make_cleanup (xfree, sals.sals);
2446 if (sal.symtab == 0)
2447 error (_("Could not find the specified line"));
2449 if (sal.line > 0 && find_line_pc_range (sal, &start_pc, &end_pc))
2450 tfind_1 (tfind_range, 0, start_pc, end_pc - 1, 0);
2452 error (_("Could not find the specified line"));
2454 do_cleanups (back_to);
2457 error (_("Invalid mode '%s'"), mode);
2459 if (has_stack_frames () || get_traceframe_number () >= 0)
2460 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
2464 mi_cmd_trace_save (char *command, char **argv, int argc)
2466 int target_saves = 0;
2469 if (argc != 1 && argc != 2)
2470 error (_("Usage: -trace-save [-r] filename"));
2475 if (strcmp (argv[0], "-r") == 0)
2478 error (_("Invalid option: %s"), argv[0]);
2485 trace_save (filename, target_saves);
2489 mi_cmd_trace_start (char *command, char **argv, int argc)
2491 start_tracing (NULL);
2495 mi_cmd_trace_status (char *command, char **argv, int argc)
2497 trace_status_mi (0);
2501 mi_cmd_trace_stop (char *command, char **argv, int argc)
2503 stop_tracing (NULL);
2504 trace_status_mi (1);
2507 /* Implement the "-ada-task-info" command. */
2510 mi_cmd_ada_task_info (char *command, char **argv, int argc)
2512 if (argc != 0 && argc != 1)
2513 error (_("Invalid MI command"));
2515 print_ada_task_info (current_uiout, argv[0], current_inferior ());