3 Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010,
4 2011 Free Software Foundation, Inc.
6 Contributed by Cygnus Solutions (a Red Hat company).
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 /* Work in progress. */
26 #include "arch-utils.h"
29 #include "gdb_string.h"
30 #include "exceptions.h"
32 #include "gdbthread.h"
35 #include "mi-getopt.h"
36 #include "mi-console.h"
40 #include "event-loop.h"
41 #include "event-top.h"
42 #include "gdbcore.h" /* For write_memory(). */
48 #include "mi-common.h"
53 #include "splay-tree.h"
54 #include "tracepoint.h"
59 #if defined HAVE_SYS_RESOURCE_H
60 #include <sys/resource.h>
73 struct ui_file *raw_stdout;
75 /* This is used to pass the current command timestamp
76 down to continuation routines. */
77 static struct mi_timestamp *current_command_ts;
79 static int do_timings = 0;
82 /* Few commands would like to know if options like --thread-group
83 were explicitly specified. This variable keeps the current
84 parsed command including all option, and make it possible. */
85 static struct mi_parse *current_context;
87 int running_result_record_printed = 1;
89 /* Flag indicating that the target has proceeded since the last
90 command was issued. */
93 extern void _initialize_mi_main (void);
94 static void mi_cmd_execute (struct mi_parse *parse);
96 static void mi_execute_cli_command (const char *cmd, int args_p,
98 static void mi_execute_async_cli_command (char *cli_command,
99 char **argv, int argc);
100 static int register_changed_p (int regnum, struct regcache *,
102 static void get_register (struct frame_info *, int regnum, int format);
104 /* Command implementations. FIXME: Is this libgdb? No. This is the MI
105 layer that calls libgdb. Any operation used in the below should be
108 static void timestamp (struct mi_timestamp *tv);
110 static void print_diff_now (struct mi_timestamp *start);
111 static void print_diff (struct mi_timestamp *start, struct mi_timestamp *end);
114 mi_cmd_gdb_exit (char *command, char **argv, int argc)
116 /* We have to print everything right here because we never return. */
118 fputs_unfiltered (current_token, raw_stdout);
119 fputs_unfiltered ("^exit\n", raw_stdout);
120 mi_out_put (uiout, raw_stdout);
121 gdb_flush (raw_stdout);
122 /* FIXME: The function called is not yet a formal libgdb function. */
123 quit_force (NULL, FROM_TTY);
127 mi_cmd_exec_next (char *command, char **argv, int argc)
129 /* FIXME: Should call a libgdb function, not a cli wrapper. */
130 if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
131 mi_execute_async_cli_command ("reverse-next", argv + 1, argc - 1);
133 mi_execute_async_cli_command ("next", argv, argc);
137 mi_cmd_exec_next_instruction (char *command, char **argv, int argc)
139 /* FIXME: Should call a libgdb function, not a cli wrapper. */
140 if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
141 mi_execute_async_cli_command ("reverse-nexti", argv + 1, argc - 1);
143 mi_execute_async_cli_command ("nexti", argv, argc);
147 mi_cmd_exec_step (char *command, char **argv, int argc)
149 /* FIXME: Should call a libgdb function, not a cli wrapper. */
150 if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
151 mi_execute_async_cli_command ("reverse-step", argv + 1, argc - 1);
153 mi_execute_async_cli_command ("step", argv, argc);
157 mi_cmd_exec_step_instruction (char *command, char **argv, int argc)
159 /* FIXME: Should call a libgdb function, not a cli wrapper. */
160 if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
161 mi_execute_async_cli_command ("reverse-stepi", argv + 1, argc - 1);
163 mi_execute_async_cli_command ("stepi", argv, argc);
167 mi_cmd_exec_finish (char *command, char **argv, int argc)
169 /* FIXME: Should call a libgdb function, not a cli wrapper. */
170 if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
171 mi_execute_async_cli_command ("reverse-finish", argv + 1, argc - 1);
173 mi_execute_async_cli_command ("finish", argv, argc);
177 mi_cmd_exec_return (char *command, char **argv, int argc)
179 /* This command doesn't really execute the target, it just pops the
180 specified number of frames. */
182 /* Call return_command with from_tty argument equal to 0 so as to
183 avoid being queried. */
184 return_command (*argv, 0);
186 /* Call return_command with from_tty argument equal to 0 so as to
187 avoid being queried. */
188 return_command (NULL, 0);
190 /* Because we have called return_command with from_tty = 0, we need
191 to print the frame here. */
192 print_stack_frame (get_selected_frame (NULL), 1, LOC_AND_ADDRESS);
196 mi_cmd_exec_jump (char *args, char **argv, int argc)
198 /* FIXME: Should call a libgdb function, not a cli wrapper. */
199 mi_execute_async_cli_command ("jump", argv, argc);
203 proceed_thread (struct thread_info *thread, int pid)
205 if (!is_stopped (thread->ptid))
208 if (pid != 0 && PIDGET (thread->ptid) != pid)
211 switch_to_thread (thread->ptid);
212 clear_proceed_status ();
213 proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 0);
218 proceed_thread_callback (struct thread_info *thread, void *arg)
220 int pid = *(int *)arg;
222 proceed_thread (thread, pid);
227 exec_continue (char **argv, int argc)
231 /* In non-stop mode, 'resume' always resumes a single thread. Therefore,
232 to resume all threads of the current inferior, or all threads in all
233 inferiors, we need to iterate over threads.
235 See comment on infcmd.c:proceed_thread_callback for rationale. */
236 if (current_context->all || current_context->thread_group != -1)
239 struct cleanup *back_to = make_cleanup_restore_current_thread ();
241 if (!current_context->all)
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 either
268 all threads, or one thread, depending on the 'scheduler-locking'
269 variable. Let's continue to do the same. */
272 do_cleanups (back_to);
277 exec_direction_forward (void *notused)
279 execution_direction = EXEC_FORWARD;
283 exec_reverse_continue (char **argv, int argc)
285 enum exec_direction_kind dir = execution_direction;
286 struct cleanup *old_chain;
288 if (dir == EXEC_ERROR)
289 error (_("Target %s does not support this command."), target_shortname);
291 if (dir == EXEC_REVERSE)
292 error (_("Already in reverse mode."));
294 if (!target_can_execute_reverse)
295 error (_("Target %s does not support this command."), target_shortname);
297 old_chain = make_cleanup (exec_direction_forward, NULL);
298 execution_direction = EXEC_REVERSE;
299 exec_continue (argv, argc);
300 do_cleanups (old_chain);
304 mi_cmd_exec_continue (char *command, char **argv, int argc)
306 if (argc > 0 && strcmp (argv[0], "--reverse") == 0)
307 exec_reverse_continue (argv + 1, argc - 1);
309 exec_continue (argv, argc);
313 interrupt_thread_callback (struct thread_info *thread, void *arg)
315 int pid = *(int *)arg;
317 if (!is_running (thread->ptid))
320 if (PIDGET (thread->ptid) != pid)
323 target_stop (thread->ptid);
327 /* Interrupt the execution of the target. Note how we must play around
328 with the token variables, in order to display the current token in
329 the result of the interrupt command, and the previous execution
330 token when the target finally stops. See comments in
333 mi_cmd_exec_interrupt (char *command, char **argv, int argc)
335 /* In all-stop mode, everything stops, so we don't need to try
336 anything specific. */
339 interrupt_target_1 (0);
343 if (current_context->all)
345 /* This will interrupt all threads in all inferiors. */
346 interrupt_target_1 (1);
348 else if (current_context->thread_group != -1)
350 struct inferior *inf = find_inferior_id (current_context->thread_group);
352 iterate_over_threads (interrupt_thread_callback, &inf->pid);
356 /* Interrupt just the current thread -- either explicitly
357 specified via --thread or whatever was current before
358 MI command was sent. */
359 interrupt_target_1 (0);
364 run_one_inferior (struct inferior *inf, void *arg)
366 if (inf->pid != FAKE_PROCESS_ID)
368 if (inf->pid != ptid_get_pid (inferior_ptid))
370 struct thread_info *tp;
372 tp = any_thread_of_process (inf->pid);
374 error (_("Inferior has no threads."));
376 switch_to_thread (tp->ptid);
381 set_current_inferior (inf);
382 switch_to_thread (null_ptid);
383 set_current_program_space (inf->pspace);
385 mi_execute_cli_command ("run", target_can_async_p (),
386 target_can_async_p () ? "&" : NULL);
391 mi_cmd_exec_run (char *command, char **argv, int argc)
393 if (current_context->all)
395 struct cleanup *back_to = save_current_space_and_thread ();
397 iterate_over_inferiors (run_one_inferior, NULL);
398 do_cleanups (back_to);
402 mi_execute_cli_command ("run", target_can_async_p (),
403 target_can_async_p () ? "&" : NULL);
409 find_thread_of_process (struct thread_info *ti, void *p)
413 if (PIDGET (ti->ptid) == pid && !is_exited (ti->ptid))
420 mi_cmd_target_detach (char *command, char **argv, int argc)
422 if (argc != 0 && argc != 1)
423 error (_("Usage: -target-detach [pid | thread-group]"));
427 struct thread_info *tp;
431 /* First see if we are dealing with a thread-group id. */
434 struct inferior *inf;
435 int id = strtoul (argv[0] + 1, &end, 0);
438 error (_("Invalid syntax of thread-group id '%s'"), argv[0]);
440 inf = find_inferior_id (id);
442 error (_("Non-existent thread-group id '%d'"), id);
448 /* We must be dealing with a pid. */
449 pid = strtol (argv[0], &end, 10);
452 error (_("Invalid identifier '%s'"), argv[0]);
455 /* Pick any thread in the desired process. Current
456 target_detach detaches from the parent of inferior_ptid. */
457 tp = iterate_over_threads (find_thread_of_process, &pid);
459 error (_("Thread group is empty"));
461 switch_to_thread (tp->ptid);
464 detach_command (NULL, 0);
468 mi_cmd_thread_select (char *command, char **argv, int argc)
471 char *mi_error_message;
474 error (_("-thread-select: USAGE: threadnum."));
476 rc = gdb_thread_select (uiout, argv[0], &mi_error_message);
478 if (rc == GDB_RC_FAIL)
480 make_cleanup (xfree, mi_error_message);
481 error ("%s", mi_error_message);
486 mi_cmd_thread_list_ids (char *command, char **argv, int argc)
489 char *mi_error_message;
492 error (_("-thread-list-ids: No arguments required."));
494 rc = gdb_list_thread_ids (uiout, &mi_error_message);
496 if (rc == GDB_RC_FAIL)
498 make_cleanup (xfree, mi_error_message);
499 error ("%s", mi_error_message);
504 mi_cmd_thread_info (char *command, char **argv, int argc)
506 if (argc != 0 && argc != 1)
507 error (_("Invalid MI command"));
509 print_thread_info (uiout, argv[0], -1);
512 struct collect_cores_data
520 collect_cores (struct thread_info *ti, void *xdata)
522 struct collect_cores_data *data = xdata;
524 if (ptid_get_pid (ti->ptid) == data->pid)
526 int core = target_core_of_thread (ti->ptid);
529 VEC_safe_push (int, data->cores, core);
536 unique (int *b, int *e)
546 struct print_one_inferior_data
549 VEC (int) *inferiors;
553 print_one_inferior (struct inferior *inferior, void *xdata)
555 struct print_one_inferior_data *top_data = xdata;
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 != FAKE_PROCESS_ID)
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 != FAKE_PROCESS_ID)
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 elements of
614 the list are obtained by splitting 'cores' on comma. */
617 output_cores (struct ui_out *uiout, const char *field_name, const char *xcores)
619 struct cleanup *back_to = make_cleanup_ui_out_list_begin_end (uiout,
621 char *cores = xstrdup (xcores);
624 make_cleanup (xfree, cores);
626 for (p = strtok (p, ","); p; p = strtok (NULL, ","))
627 ui_out_field_string (uiout, NULL, p);
629 do_cleanups (back_to);
633 free_vector_of_ints (void *xvector)
635 VEC (int) **vector = xvector;
637 VEC_free (int, *vector);
641 do_nothing (splay_tree_key k)
646 free_vector_of_osdata_items (splay_tree_value xvalue)
648 VEC (osdata_item_s) *value = (VEC (osdata_item_s) *) xvalue;
650 /* We don't free the items itself, it will be done separately. */
651 VEC_free (osdata_item_s, value);
655 splay_tree_int_comparator (splay_tree_key xa, splay_tree_key xb)
664 free_splay_tree (void *xt)
667 splay_tree_delete (t);
671 list_available_thread_groups (VEC (int) *ids, int recurse)
674 struct osdata_item *item;
677 /* This keeps a map from integer (pid) to VEC (struct osdata_item *)*
678 The vector contains information about all threads for the given pid.
679 This is assigned an initial value to avoid "may be used uninitialized"
681 splay_tree tree = NULL;
683 /* get_osdata will throw if it cannot return data. */
684 data = get_osdata ("processes");
685 make_cleanup_osdata_free (data);
689 struct osdata *threads = get_osdata ("threads");
691 make_cleanup_osdata_free (threads);
692 tree = splay_tree_new (splay_tree_int_comparator,
694 free_vector_of_osdata_items);
695 make_cleanup (free_splay_tree, tree);
698 VEC_iterate (osdata_item_s, threads->items,
702 const char *pid = get_osdata_column (item, "pid");
703 int pid_i = strtoul (pid, NULL, 0);
704 VEC (osdata_item_s) *vec = 0;
706 splay_tree_node n = splay_tree_lookup (tree, pid_i);
709 VEC_safe_push (osdata_item_s, vec, item);
710 splay_tree_insert (tree, pid_i, (splay_tree_value)vec);
714 vec = (VEC (osdata_item_s) *) n->value;
715 VEC_safe_push (osdata_item_s, vec, item);
716 n->value = (splay_tree_value) vec;
721 make_cleanup_ui_out_list_begin_end (uiout, "groups");
724 VEC_iterate (osdata_item_s, data->items,
728 struct cleanup *back_to;
730 const char *pid = get_osdata_column (item, "pid");
731 const char *cmd = get_osdata_column (item, "command");
732 const char *user = get_osdata_column (item, "user");
733 const char *cores = get_osdata_column (item, "cores");
735 int pid_i = strtoul (pid, NULL, 0);
737 /* At present, the target will return all available processes
738 and if information about specific ones was required, we filter
739 undesired processes here. */
740 if (ids && bsearch (&pid_i, VEC_address (int, ids),
741 VEC_length (int, ids),
742 sizeof (int), compare_positive_ints) == NULL)
746 back_to = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
748 ui_out_field_fmt (uiout, "id", "%s", pid);
749 ui_out_field_string (uiout, "type", "process");
751 ui_out_field_string (uiout, "description", cmd);
753 ui_out_field_string (uiout, "user", user);
755 output_cores (uiout, "cores", cores);
759 splay_tree_node n = splay_tree_lookup (tree, pid_i);
762 VEC (osdata_item_s) *children = (VEC (osdata_item_s) *) n->value;
763 struct osdata_item *child;
766 make_cleanup_ui_out_list_begin_end (uiout, "threads");
769 VEC_iterate (osdata_item_s, children, ix_child, child);
772 struct cleanup *back_to_2 =
773 make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
774 const char *tid = get_osdata_column (child, "tid");
775 const char *tcore = get_osdata_column (child, "core");
777 ui_out_field_string (uiout, "id", tid);
779 ui_out_field_string (uiout, "core", tcore);
781 do_cleanups (back_to_2);
786 do_cleanups (back_to);
791 mi_cmd_list_thread_groups (char *command, char **argv, int argc)
793 struct cleanup *back_to;
800 AVAILABLE_OPT, RECURSE_OPT
802 static struct mi_opt opts[] =
804 {"-available", AVAILABLE_OPT, 0},
805 {"-recurse", RECURSE_OPT, 1},
814 int opt = mi_getopt ("-list-thread-groups", argc, argv, opts,
819 switch ((enum opt) opt)
825 if (strcmp (optarg, "0") == 0)
827 else if (strcmp (optarg, "1") == 0)
830 error (_("only '0' and '1' are valid values "
831 "for the '--recurse' option"));
836 for (; optind < argc; ++optind)
841 if (*(argv[optind]) != 'i')
842 error (_("invalid syntax of group id '%s'"), argv[optind]);
844 inf = strtoul (argv[optind] + 1, &end, 0);
847 error (_("invalid syntax of group id '%s'"), argv[optind]);
848 VEC_safe_push (int, ids, inf);
850 if (VEC_length (int, ids) > 1)
851 qsort (VEC_address (int, ids),
852 VEC_length (int, ids),
853 sizeof (int), compare_positive_ints);
855 back_to = make_cleanup (free_vector_of_ints, &ids);
859 list_available_thread_groups (ids, recurse);
861 else if (VEC_length (int, ids) == 1)
863 /* Local thread groups, single id. */
864 int id = *VEC_address (int, ids);
865 struct inferior *inf = find_inferior_id (id);
868 error (_("Non-existent thread group id '%d'"), id);
870 print_thread_info (uiout, NULL, inf->pid);
874 struct print_one_inferior_data data;
876 data.recurse = recurse;
877 data.inferiors = ids;
879 /* Local thread groups. Either no explicit ids -- and we
880 print everything, or several explicit ids. In both cases,
881 we print more than one group, and have to use 'groups'
882 as the top-level element. */
883 make_cleanup_ui_out_list_begin_end (uiout, "groups");
884 update_thread_list ();
885 iterate_over_inferiors (print_one_inferior, &data);
888 do_cleanups (back_to);
892 mi_cmd_data_list_register_names (char *command, char **argv, int argc)
894 struct gdbarch *gdbarch;
897 struct cleanup *cleanup;
899 /* Note that the test for a valid register must include checking the
900 gdbarch_register_name because gdbarch_num_regs may be allocated for
901 the union of the register sets within a family of related processors.
902 In this case, some entries of gdbarch_register_name will change depending
903 upon the particular processor being debugged. */
905 gdbarch = get_current_arch ();
906 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
908 cleanup = make_cleanup_ui_out_list_begin_end (uiout, "register-names");
910 if (argc == 0) /* No args, just do all the regs. */
916 if (gdbarch_register_name (gdbarch, regnum) == NULL
917 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
918 ui_out_field_string (uiout, NULL, "");
920 ui_out_field_string (uiout, NULL,
921 gdbarch_register_name (gdbarch, regnum));
925 /* Else, list of register #s, just do listed regs. */
926 for (i = 0; i < argc; i++)
928 regnum = atoi (argv[i]);
929 if (regnum < 0 || regnum >= numregs)
930 error (_("bad register number"));
932 if (gdbarch_register_name (gdbarch, regnum) == NULL
933 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
934 ui_out_field_string (uiout, NULL, "");
936 ui_out_field_string (uiout, NULL,
937 gdbarch_register_name (gdbarch, regnum));
939 do_cleanups (cleanup);
943 mi_cmd_data_list_changed_registers (char *command, char **argv, int argc)
945 static struct regcache *this_regs = NULL;
946 struct regcache *prev_regs;
947 struct gdbarch *gdbarch;
948 int regnum, numregs, changed;
950 struct cleanup *cleanup;
952 /* The last time we visited this function, the current frame's register
953 contents were saved in THIS_REGS. Move THIS_REGS over to PREV_REGS,
954 and refresh THIS_REGS with the now-current register contents. */
956 prev_regs = this_regs;
957 this_regs = frame_save_as_regcache (get_selected_frame (NULL));
958 cleanup = make_cleanup_regcache_xfree (prev_regs);
960 /* Note that the test for a valid register must include checking the
961 gdbarch_register_name because gdbarch_num_regs may be allocated for
962 the union of the register sets within a family of related processors.
963 In this case, some entries of gdbarch_register_name will change depending
964 upon the particular processor being debugged. */
966 gdbarch = get_regcache_arch (this_regs);
967 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
969 make_cleanup_ui_out_list_begin_end (uiout, "changed-registers");
971 if (argc == 0) /* No args, just do all the regs. */
977 if (gdbarch_register_name (gdbarch, regnum) == NULL
978 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
980 changed = register_changed_p (regnum, prev_regs, this_regs);
982 error (_("-data-list-changed-registers: "
983 "Unable to read register contents."));
985 ui_out_field_int (uiout, NULL, regnum);
989 /* Else, list of register #s, just do listed regs. */
990 for (i = 0; i < argc; i++)
992 regnum = atoi (argv[i]);
996 && gdbarch_register_name (gdbarch, regnum) != NULL
997 && *gdbarch_register_name (gdbarch, regnum) != '\000')
999 changed = register_changed_p (regnum, prev_regs, this_regs);
1001 error (_("-data-list-changed-registers: "
1002 "Unable to read register contents."));
1004 ui_out_field_int (uiout, NULL, regnum);
1007 error (_("bad register number"));
1009 do_cleanups (cleanup);
1013 register_changed_p (int regnum, struct regcache *prev_regs,
1014 struct regcache *this_regs)
1016 struct gdbarch *gdbarch = get_regcache_arch (this_regs);
1017 gdb_byte prev_buffer[MAX_REGISTER_SIZE];
1018 gdb_byte this_buffer[MAX_REGISTER_SIZE];
1019 enum register_status prev_status;
1020 enum register_status this_status;
1022 /* First time through or after gdbarch change consider all registers
1024 if (!prev_regs || get_regcache_arch (prev_regs) != gdbarch)
1027 /* Get register contents and compare. */
1028 prev_status = regcache_cooked_read (prev_regs, regnum, prev_buffer);
1029 this_status = regcache_cooked_read (this_regs, regnum, this_buffer);
1031 if (this_status != prev_status)
1033 else if (this_status == REG_VALID)
1034 return memcmp (prev_buffer, this_buffer,
1035 register_size (gdbarch, regnum)) != 0;
1040 /* Return a list of register number and value pairs. The valid
1041 arguments expected are: a letter indicating the format in which to
1042 display the registers contents. This can be one of: x (hexadecimal), d
1043 (decimal), N (natural), t (binary), o (octal), r (raw). After the
1044 format argumetn there can be a sequence of numbers, indicating which
1045 registers to fetch the content of. If the format is the only argument,
1046 a list of all the registers with their values is returned. */
1048 mi_cmd_data_list_register_values (char *command, char **argv, int argc)
1050 struct frame_info *frame;
1051 struct gdbarch *gdbarch;
1052 int regnum, numregs, format;
1054 struct cleanup *list_cleanup, *tuple_cleanup;
1056 /* Note that the test for a valid register must include checking the
1057 gdbarch_register_name because gdbarch_num_regs may be allocated for
1058 the union of the register sets within a family of related processors.
1059 In this case, some entries of gdbarch_register_name will change depending
1060 upon the particular processor being debugged. */
1063 error (_("-data-list-register-values: Usage: "
1064 "-data-list-register-values <format> [<regnum1>...<regnumN>]"));
1066 format = (int) argv[0][0];
1068 frame = get_selected_frame (NULL);
1069 gdbarch = get_frame_arch (frame);
1070 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
1072 list_cleanup = make_cleanup_ui_out_list_begin_end (uiout, "register-values");
1074 if (argc == 1) /* No args, beside the format: do all the regs. */
1080 if (gdbarch_register_name (gdbarch, regnum) == NULL
1081 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
1083 tuple_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1084 ui_out_field_int (uiout, "number", regnum);
1085 get_register (frame, regnum, format);
1086 do_cleanups (tuple_cleanup);
1090 /* Else, list of register #s, just do listed regs. */
1091 for (i = 1; i < argc; i++)
1093 regnum = atoi (argv[i]);
1097 && gdbarch_register_name (gdbarch, regnum) != NULL
1098 && *gdbarch_register_name (gdbarch, regnum) != '\000')
1100 tuple_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1101 ui_out_field_int (uiout, "number", regnum);
1102 get_register (frame, regnum, format);
1103 do_cleanups (tuple_cleanup);
1106 error (_("bad register number"));
1108 do_cleanups (list_cleanup);
1111 /* Output one register's contents in the desired format. */
1113 get_register (struct frame_info *frame, int regnum, int format)
1115 struct gdbarch *gdbarch = get_frame_arch (frame);
1117 enum lval_type lval;
1118 static struct ui_stream *stb = NULL;
1121 stb = ui_out_stream_new (uiout);
1126 val = get_frame_register_value (frame, regnum);
1128 if (value_optimized_out (val))
1129 error (_("Optimized out"));
1134 char *ptr, buf[1024];
1135 const gdb_byte *valaddr = value_contents_for_printing (val);
1139 for (j = 0; j < register_size (gdbarch, regnum); j++)
1141 int idx = gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG ?
1142 j : register_size (gdbarch, regnum) - 1 - j;
1144 sprintf (ptr, "%02x", (unsigned char) valaddr[idx]);
1147 ui_out_field_string (uiout, "value", buf);
1148 /*fputs_filtered (buf, gdb_stdout); */
1152 struct value_print_options opts;
1154 get_formatted_print_options (&opts, format);
1156 val_print (value_type (val),
1157 value_contents_for_printing (val),
1158 value_embedded_offset (val), 0,
1159 stb->stream, 0, val, &opts, current_language);
1160 ui_out_field_stream (uiout, "value", stb);
1161 ui_out_stream_delete (stb);
1165 /* Write given values into registers. The registers and values are
1166 given as pairs. The corresponding MI command is
1167 -data-write-register-values <format>
1168 [<regnum1> <value1>...<regnumN> <valueN>] */
1170 mi_cmd_data_write_register_values (char *command, char **argv, int argc)
1172 struct regcache *regcache;
1173 struct gdbarch *gdbarch;
1177 /* Note that the test for a valid register must include checking the
1178 gdbarch_register_name because gdbarch_num_regs may be allocated for
1179 the union of the register sets within a family of related processors.
1180 In this case, some entries of gdbarch_register_name will change depending
1181 upon the particular processor being debugged. */
1183 regcache = get_current_regcache ();
1184 gdbarch = get_regcache_arch (regcache);
1185 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
1188 error (_("-data-write-register-values: Usage: -data-write-register-"
1189 "values <format> [<regnum1> <value1>...<regnumN> <valueN>]"));
1191 format = (int) argv[0][0];
1193 if (!target_has_registers)
1194 error (_("-data-write-register-values: No registers."));
1197 error (_("-data-write-register-values: No regs and values specified."));
1200 error (_("-data-write-register-values: "
1201 "Regs and vals are not in pairs."));
1203 for (i = 1; i < argc; i = i + 2)
1205 int regnum = atoi (argv[i]);
1207 if (regnum >= 0 && regnum < numregs
1208 && gdbarch_register_name (gdbarch, regnum)
1209 && *gdbarch_register_name (gdbarch, regnum))
1213 /* Get the value as a number. */
1214 value = parse_and_eval_address (argv[i + 1]);
1216 /* Write it down. */
1217 regcache_cooked_write_signed (regcache, regnum, value);
1220 error (_("bad register number"));
1224 /* Evaluate the value of the argument. The argument is an
1225 expression. If the expression contains spaces it needs to be
1226 included in double quotes. */
1228 mi_cmd_data_evaluate_expression (char *command, char **argv, int argc)
1230 struct expression *expr;
1231 struct cleanup *old_chain = NULL;
1233 struct ui_stream *stb = NULL;
1234 struct value_print_options opts;
1236 stb = ui_out_stream_new (uiout);
1240 ui_out_stream_delete (stb);
1241 error (_("-data-evaluate-expression: "
1242 "Usage: -data-evaluate-expression expression"));
1245 expr = parse_expression (argv[0]);
1247 old_chain = make_cleanup (free_current_contents, &expr);
1249 val = evaluate_expression (expr);
1251 /* Print the result of the expression evaluation. */
1252 get_user_print_options (&opts);
1254 common_val_print (val, stb->stream, 0, &opts, current_language);
1256 ui_out_field_stream (uiout, "value", stb);
1257 ui_out_stream_delete (stb);
1259 do_cleanups (old_chain);
1262 /* DATA-MEMORY-READ:
1264 ADDR: start address of data to be dumped.
1265 WORD-FORMAT: a char indicating format for the ``word''. See
1267 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
1268 NR_ROW: Number of rows.
1269 NR_COL: The number of colums (words per row).
1270 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
1271 ASCHAR for unprintable characters.
1273 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
1274 displayes them. Returns:
1276 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
1279 The number of bytes read is SIZE*ROW*COL. */
1282 mi_cmd_data_read_memory (char *command, char **argv, int argc)
1284 struct gdbarch *gdbarch = get_current_arch ();
1285 struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
1291 struct type *word_type;
1304 static struct mi_opt opts[] =
1306 {"o", OFFSET_OPT, 1},
1312 int opt = mi_getopt ("-data-read-memory", argc, argv, opts,
1317 switch ((enum opt) opt)
1320 offset = atol (optarg);
1327 if (argc < 5 || argc > 6)
1328 error (_("-data-read-memory: Usage: "
1329 "ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR]."));
1331 /* Extract all the arguments. */
1333 /* Start address of the memory dump. */
1334 addr = parse_and_eval_address (argv[0]) + offset;
1335 /* The format character to use when displaying a memory word. See
1336 the ``x'' command. */
1337 word_format = argv[1][0];
1338 /* The size of the memory word. */
1339 word_size = atol (argv[2]);
1343 word_type = builtin_type (gdbarch)->builtin_int8;
1347 word_type = builtin_type (gdbarch)->builtin_int16;
1351 word_type = builtin_type (gdbarch)->builtin_int32;
1355 word_type = builtin_type (gdbarch)->builtin_int64;
1359 word_type = builtin_type (gdbarch)->builtin_int8;
1362 /* The number of rows. */
1363 nr_rows = atol (argv[3]);
1365 error (_("-data-read-memory: invalid number of rows."));
1367 /* Number of bytes per row. */
1368 nr_cols = atol (argv[4]);
1370 error (_("-data-read-memory: invalid number of columns."));
1372 /* The un-printable character when printing ascii. */
1378 /* Create a buffer and read it in. */
1379 total_bytes = word_size * nr_rows * nr_cols;
1380 mbuf = xcalloc (total_bytes, 1);
1381 make_cleanup (xfree, mbuf);
1383 /* Dispatch memory reads to the topmost target, not the flattened
1385 nr_bytes = target_read (current_target.beneath,
1386 TARGET_OBJECT_MEMORY, NULL, mbuf,
1389 error (_("Unable to read memory."));
1391 /* Output the header information. */
1392 ui_out_field_core_addr (uiout, "addr", gdbarch, addr);
1393 ui_out_field_int (uiout, "nr-bytes", nr_bytes);
1394 ui_out_field_int (uiout, "total-bytes", total_bytes);
1395 ui_out_field_core_addr (uiout, "next-row",
1396 gdbarch, addr + word_size * nr_cols);
1397 ui_out_field_core_addr (uiout, "prev-row",
1398 gdbarch, addr - word_size * nr_cols);
1399 ui_out_field_core_addr (uiout, "next-page", gdbarch, addr + total_bytes);
1400 ui_out_field_core_addr (uiout, "prev-page", gdbarch, addr - total_bytes);
1402 /* Build the result as a two dimentional table. */
1404 struct ui_stream *stream = ui_out_stream_new (uiout);
1405 struct cleanup *cleanup_list_memory;
1409 cleanup_list_memory = make_cleanup_ui_out_list_begin_end (uiout, "memory");
1410 for (row = 0, row_byte = 0;
1412 row++, row_byte += nr_cols * word_size)
1416 struct cleanup *cleanup_tuple;
1417 struct cleanup *cleanup_list_data;
1418 struct value_print_options opts;
1420 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1421 ui_out_field_core_addr (uiout, "addr", gdbarch, addr + row_byte);
1422 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr +
1424 cleanup_list_data = make_cleanup_ui_out_list_begin_end (uiout, "data");
1425 get_formatted_print_options (&opts, word_format);
1426 for (col = 0, col_byte = row_byte;
1428 col++, col_byte += word_size)
1430 if (col_byte + word_size > nr_bytes)
1432 ui_out_field_string (uiout, NULL, "N/A");
1436 ui_file_rewind (stream->stream);
1437 print_scalar_formatted (mbuf + col_byte, word_type, &opts,
1438 word_asize, stream->stream);
1439 ui_out_field_stream (uiout, NULL, stream);
1442 do_cleanups (cleanup_list_data);
1447 ui_file_rewind (stream->stream);
1448 for (byte = row_byte;
1449 byte < row_byte + word_size * nr_cols; byte++)
1451 if (byte >= nr_bytes)
1453 fputc_unfiltered ('X', stream->stream);
1455 else if (mbuf[byte] < 32 || mbuf[byte] > 126)
1457 fputc_unfiltered (aschar, stream->stream);
1460 fputc_unfiltered (mbuf[byte], stream->stream);
1462 ui_out_field_stream (uiout, "ascii", stream);
1464 do_cleanups (cleanup_tuple);
1466 ui_out_stream_delete (stream);
1467 do_cleanups (cleanup_list_memory);
1469 do_cleanups (cleanups);
1473 mi_cmd_data_read_memory_bytes (char *command, char **argv, int argc)
1475 struct gdbarch *gdbarch = get_current_arch ();
1476 struct cleanup *cleanups;
1479 memory_read_result_s *read_result;
1481 VEC(memory_read_result_s) *result;
1489 static struct mi_opt opts[] =
1491 {"o", OFFSET_OPT, 1},
1497 int opt = mi_getopt ("-data-read-memory-bytes", argc, argv, opts,
1501 switch ((enum opt) opt)
1504 offset = atol (optarg);
1512 error (_("Usage: [ -o OFFSET ] ADDR LENGTH."));
1514 addr = parse_and_eval_address (argv[0]) + offset;
1515 length = atol (argv[1]);
1517 result = read_memory_robust (current_target.beneath, addr, length);
1519 cleanups = make_cleanup (free_memory_read_result_vector, result);
1521 if (VEC_length (memory_read_result_s, result) == 0)
1522 error (_("Unable to read memory."));
1524 make_cleanup_ui_out_list_begin_end (uiout, "memory");
1526 VEC_iterate (memory_read_result_s, result, ix, read_result);
1529 struct cleanup *t = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1533 ui_out_field_core_addr (uiout, "begin", gdbarch, read_result->begin);
1534 ui_out_field_core_addr (uiout, "offset", gdbarch, read_result->begin
1536 ui_out_field_core_addr (uiout, "end", gdbarch, read_result->end);
1538 data = xmalloc ((read_result->end - read_result->begin) * 2 + 1);
1540 for (i = 0, p = data;
1541 i < (read_result->end - read_result->begin);
1544 sprintf (p, "%02x", read_result->data[i]);
1546 ui_out_field_string (uiout, "contents", data);
1550 do_cleanups (cleanups);
1554 /* DATA-MEMORY-WRITE:
1556 COLUMN_OFFSET: optional argument. Must be preceeded by '-o'. The
1557 offset from the beginning of the memory grid row where the cell to
1559 ADDR: start address of the row in the memory grid where the memory
1560 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
1561 the location to write to.
1562 FORMAT: a char indicating format for the ``word''. See
1564 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
1565 VALUE: value to be written into the memory address.
1567 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1571 mi_cmd_data_write_memory (char *command, char **argv, int argc)
1573 struct gdbarch *gdbarch = get_current_arch ();
1574 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1578 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1579 enough when using a compiler other than GCC. */
1582 struct cleanup *old_chain;
1590 static struct mi_opt opts[] =
1592 {"o", OFFSET_OPT, 1},
1598 int opt = mi_getopt ("-data-write-memory", argc, argv, opts,
1603 switch ((enum opt) opt)
1606 offset = atol (optarg);
1614 error (_("-data-write-memory: Usage: "
1615 "[-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE."));
1617 /* Extract all the arguments. */
1618 /* Start address of the memory dump. */
1619 addr = parse_and_eval_address (argv[0]);
1620 /* The format character to use when displaying a memory word. See
1621 the ``x'' command. */
1622 word_format = argv[1][0];
1623 /* The size of the memory word. */
1624 word_size = atol (argv[2]);
1626 /* Calculate the real address of the write destination. */
1627 addr += (offset * word_size);
1629 /* Get the value as a number. */
1630 value = parse_and_eval_address (argv[3]);
1631 /* Get the value into an array. */
1632 buffer = xmalloc (word_size);
1633 old_chain = make_cleanup (xfree, buffer);
1634 store_signed_integer (buffer, word_size, byte_order, value);
1635 /* Write it down to memory. */
1636 write_memory (addr, buffer, word_size);
1637 /* Free the buffer. */
1638 do_cleanups (old_chain);
1641 /* DATA-MEMORY-WRITE-RAW:
1644 DATA: string of bytes to write at that address. */
1646 mi_cmd_data_write_memory_bytes (char *command, char **argv, int argc)
1652 struct cleanup *back_to;
1655 error (_("Usage: ADDR DATA."));
1657 addr = parse_and_eval_address (argv[0]);
1659 len = strlen (cdata)/2;
1661 data = xmalloc (len);
1662 back_to = make_cleanup (xfree, data);
1664 for (i = 0; i < len; ++i)
1667 sscanf (cdata + i * 2, "%02x", &x);
1668 data[i] = (gdb_byte)x;
1671 r = target_write_memory (addr, data, len);
1673 error (_("Could not write memory"));
1675 do_cleanups (back_to);
1680 mi_cmd_enable_timings (char *command, char **argv, int argc)
1686 if (strcmp (argv[0], "yes") == 0)
1688 else if (strcmp (argv[0], "no") == 0)
1699 error (_("-enable-timings: Usage: %s {yes|no}"), command);
1703 mi_cmd_list_features (char *command, char **argv, int argc)
1707 struct cleanup *cleanup = NULL;
1709 cleanup = make_cleanup_ui_out_list_begin_end (uiout, "features");
1710 ui_out_field_string (uiout, NULL, "frozen-varobjs");
1711 ui_out_field_string (uiout, NULL, "pending-breakpoints");
1712 ui_out_field_string (uiout, NULL, "thread-info");
1713 ui_out_field_string (uiout, NULL, "data-read-memory-bytes");
1716 ui_out_field_string (uiout, NULL, "python");
1719 do_cleanups (cleanup);
1723 error (_("-list-features should be passed no arguments"));
1727 mi_cmd_list_target_features (char *command, char **argv, int argc)
1731 struct cleanup *cleanup = NULL;
1733 cleanup = make_cleanup_ui_out_list_begin_end (uiout, "features");
1734 if (target_can_async_p ())
1735 ui_out_field_string (uiout, NULL, "async");
1736 if (target_can_execute_reverse)
1737 ui_out_field_string (uiout, NULL, "reverse");
1739 do_cleanups (cleanup);
1743 error (_("-list-target-features should be passed no arguments"));
1747 mi_cmd_add_inferior (char *command, char **argv, int argc)
1749 struct inferior *inf;
1752 error (_("-add-inferior should be passed no arguments"));
1754 inf = add_inferior_with_spaces ();
1756 ui_out_field_fmt (uiout, "inferior", "i%d", inf->num);
1759 /* Callback used to find the first inferior other than the
1763 get_other_inferior (struct inferior *inf, void *arg)
1765 if (inf == current_inferior ())
1772 mi_cmd_remove_inferior (char *command, char **argv, int argc)
1775 struct inferior *inf;
1778 error (_("-remove-inferior should be passed a single argument"));
1780 if (sscanf (argv[0], "i%d", &id) != 1)
1781 error (_("the thread group id is syntactically invalid"));
1783 inf = find_inferior_id (id);
1785 error (_("the specified thread group does not exist"));
1787 if (inf->pid != FAKE_PROCESS_ID)
1788 error (_("cannot remove an active inferior"));
1790 if (inf == current_inferior ())
1792 struct thread_info *tp = 0;
1793 struct inferior *new_inferior
1794 = iterate_over_inferiors (get_other_inferior, NULL);
1796 if (new_inferior == NULL)
1797 error (_("Cannot remove last inferior"));
1799 set_current_inferior (new_inferior);
1800 if (new_inferior->pid != FAKE_PROCESS_ID)
1801 tp = any_thread_of_process (new_inferior->pid);
1802 switch_to_thread (tp ? tp->ptid : null_ptid);
1803 set_current_program_space (new_inferior->pspace);
1806 delete_inferior_1 (inf, 1 /* silent */);
1811 /* Execute a command within a safe environment.
1812 Return <0 for error; >=0 for ok.
1814 args->action will tell mi_execute_command what action
1815 to perfrom after the given command has executed (display/suppress
1816 prompt, display error). */
1819 captured_mi_execute_command (struct ui_out *uiout, void *data)
1821 struct cleanup *cleanup;
1822 struct mi_parse *context = (struct mi_parse *) data;
1825 current_command_ts = context->cmd_start;
1827 current_token = xstrdup (context->token);
1828 cleanup = make_cleanup (free_current_contents, ¤t_token);
1830 running_result_record_printed = 0;
1832 switch (context->op)
1835 /* A MI command was read from the input stream. */
1837 /* FIXME: gdb_???? */
1838 fprintf_unfiltered (raw_stdout, " token=`%s' command=`%s' args=`%s'\n",
1839 context->token, context->command, context->args);
1842 mi_cmd_execute (context);
1844 /* Print the result if there were no errors.
1846 Remember that on the way out of executing a command, you have
1847 to directly use the mi_interp's uiout, since the command could
1848 have reset the interpreter, in which case the current uiout
1849 will most likely crash in the mi_out_* routines. */
1850 if (!running_result_record_printed)
1852 fputs_unfiltered (context->token, raw_stdout);
1853 /* There's no particularly good reason why target-connect results
1854 in not ^done. Should kill ^connected for MI3. */
1855 fputs_unfiltered (strcmp (context->command, "target-select") == 0
1856 ? "^connected" : "^done", raw_stdout);
1857 mi_out_put (uiout, raw_stdout);
1858 mi_out_rewind (uiout);
1859 mi_print_timing_maybe ();
1860 fputs_unfiltered ("\n", raw_stdout);
1863 /* The command does not want anything to be printed. In that
1864 case, the command probably should not have written anything
1865 to uiout, but in case it has written something, discard it. */
1866 mi_out_rewind (uiout);
1873 /* A CLI command was read from the input stream. */
1874 /* This "feature" will be removed as soon as we have a
1875 complete set of mi commands. */
1876 /* Echo the command on the console. */
1877 fprintf_unfiltered (gdb_stdlog, "%s\n", context->command);
1878 /* Call the "console" interpreter. */
1879 argv[0] = "console";
1880 argv[1] = context->command;
1881 mi_cmd_interpreter_exec ("-interpreter-exec", argv, 2);
1883 /* If we changed interpreters, DON'T print out anything. */
1884 if (current_interp_named_p (INTERP_MI)
1885 || current_interp_named_p (INTERP_MI1)
1886 || current_interp_named_p (INTERP_MI2)
1887 || current_interp_named_p (INTERP_MI3))
1889 if (!running_result_record_printed)
1891 fputs_unfiltered (context->token, raw_stdout);
1892 fputs_unfiltered ("^done", raw_stdout);
1893 mi_out_put (uiout, raw_stdout);
1894 mi_out_rewind (uiout);
1895 mi_print_timing_maybe ();
1896 fputs_unfiltered ("\n", raw_stdout);
1899 mi_out_rewind (uiout);
1906 do_cleanups (cleanup);
1911 /* Print a gdb exception to the MI output stream. */
1914 mi_print_exception (const char *token, struct gdb_exception exception)
1916 fputs_unfiltered (token, raw_stdout);
1917 fputs_unfiltered ("^error,msg=\"", raw_stdout);
1918 if (exception.message == NULL)
1919 fputs_unfiltered ("unknown error", raw_stdout);
1921 fputstr_unfiltered (exception.message, '"', raw_stdout);
1922 fputs_unfiltered ("\"\n", raw_stdout);
1926 mi_execute_command (char *cmd, int from_tty)
1929 struct mi_parse *command = NULL;
1930 volatile struct gdb_exception exception;
1932 /* This is to handle EOF (^D). We just quit gdb. */
1933 /* FIXME: we should call some API function here. */
1935 quit_force (NULL, from_tty);
1937 target_log_command (cmd);
1939 TRY_CATCH (exception, RETURN_MASK_ALL)
1941 command = mi_parse (cmd, &token);
1943 if (exception.reason < 0)
1945 mi_print_exception (token, exception);
1950 struct gdb_exception result;
1951 ptid_t previous_ptid = inferior_ptid;
1953 command->token = token;
1957 command->cmd_start = (struct mi_timestamp *)
1958 xmalloc (sizeof (struct mi_timestamp));
1959 timestamp (command->cmd_start);
1962 result = catch_exception (uiout, captured_mi_execute_command, command,
1964 if (result.reason < 0)
1966 /* The command execution failed and error() was called
1968 mi_print_exception (command->token, result);
1969 mi_out_rewind (uiout);
1972 bpstat_do_actions ();
1974 if (/* The notifications are only output when the top-level
1975 interpreter (specified on the command line) is MI. */
1976 ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ()))
1977 /* Don't try report anything if there are no threads --
1978 the program is dead. */
1979 && thread_count () != 0
1980 /* -thread-select explicitly changes thread. If frontend uses that
1981 internally, we don't want to emit =thread-selected, since
1982 =thread-selected is supposed to indicate user's intentions. */
1983 && strcmp (command->command, "thread-select") != 0)
1985 struct mi_interp *mi = top_level_interpreter_data ();
1986 int report_change = 0;
1988 if (command->thread == -1)
1990 report_change = (!ptid_equal (previous_ptid, null_ptid)
1991 && !ptid_equal (inferior_ptid, previous_ptid)
1992 && !ptid_equal (inferior_ptid, null_ptid));
1994 else if (!ptid_equal (inferior_ptid, null_ptid))
1996 struct thread_info *ti = inferior_thread ();
1998 report_change = (ti->num != command->thread);
2003 struct thread_info *ti = inferior_thread ();
2005 target_terminal_ours ();
2006 fprintf_unfiltered (mi->event_channel,
2007 "thread-selected,id=\"%d\"",
2009 gdb_flush (mi->event_channel);
2013 mi_parse_free (command);
2016 fputs_unfiltered ("(gdb) \n", raw_stdout);
2017 gdb_flush (raw_stdout);
2018 /* Print any buffered hook code. */
2023 mi_cmd_execute (struct mi_parse *parse)
2025 struct cleanup *cleanup;
2027 prepare_execute_command ();
2029 cleanup = make_cleanup (null_cleanup, NULL);
2031 if (parse->all && parse->thread_group != -1)
2032 error (_("Cannot specify --thread-group together with --all"));
2034 if (parse->all && parse->thread != -1)
2035 error (_("Cannot specify --thread together with --all"));
2037 if (parse->thread_group != -1 && parse->thread != -1)
2038 error (_("Cannot specify --thread together with --thread-group"));
2040 if (parse->frame != -1 && parse->thread == -1)
2041 error (_("Cannot specify --frame without --thread"));
2043 if (parse->thread_group != -1)
2045 struct inferior *inf = find_inferior_id (parse->thread_group);
2046 struct thread_info *tp = 0;
2049 error (_("Invalid thread group for the --thread-group option"));
2051 set_current_inferior (inf);
2052 /* This behaviour means that if --thread-group option identifies
2053 an inferior with multiple threads, then a random one will be picked.
2054 This is not a problem -- frontend should always provide --thread if
2055 it wishes to operate on a specific thread. */
2056 if (inf->pid != FAKE_PROCESS_ID)
2057 tp = any_thread_of_process (inf->pid);
2058 switch_to_thread (tp ? tp->ptid : null_ptid);
2059 set_current_program_space (inf->pspace);
2062 if (parse->thread != -1)
2064 struct thread_info *tp = find_thread_id (parse->thread);
2067 error (_("Invalid thread id: %d"), parse->thread);
2069 if (is_exited (tp->ptid))
2070 error (_("Thread id: %d has terminated"), parse->thread);
2072 switch_to_thread (tp->ptid);
2075 if (parse->frame != -1)
2077 struct frame_info *fid;
2078 int frame = parse->frame;
2080 fid = find_relative_frame (get_current_frame (), &frame);
2082 /* find_relative_frame was successful */
2085 error (_("Invalid frame id: %d"), frame);
2088 current_context = parse;
2090 if (parse->cmd->argv_func != NULL)
2091 parse->cmd->argv_func (parse->command, parse->argv, parse->argc);
2092 else if (parse->cmd->cli.cmd != 0)
2094 /* FIXME: DELETE THIS. */
2095 /* The operation is still implemented by a cli command. */
2096 /* Must be a synchronous one. */
2097 mi_execute_cli_command (parse->cmd->cli.cmd, parse->cmd->cli.args_p,
2102 /* FIXME: DELETE THIS. */
2103 struct ui_file *stb;
2105 stb = mem_fileopen ();
2107 fputs_unfiltered ("Undefined mi command: ", stb);
2108 fputstr_unfiltered (parse->command, '"', stb);
2109 fputs_unfiltered (" (missing implementation)", stb);
2111 make_cleanup_ui_file_delete (stb);
2114 do_cleanups (cleanup);
2117 /* FIXME: This is just a hack so we can get some extra commands going.
2118 We don't want to channel things through the CLI, but call libgdb directly.
2119 Use only for synchronous commands. */
2122 mi_execute_cli_command (const char *cmd, int args_p, const char *args)
2126 struct cleanup *old_cleanups;
2130 run = xstrprintf ("%s %s", cmd, args);
2132 run = xstrdup (cmd);
2134 /* FIXME: gdb_???? */
2135 fprintf_unfiltered (gdb_stdout, "cli=%s run=%s\n",
2137 old_cleanups = make_cleanup (xfree, run);
2138 execute_command ( /*ui */ run, 0 /*from_tty */ );
2139 do_cleanups (old_cleanups);
2145 mi_execute_async_cli_command (char *cli_command, char **argv, int argc)
2147 struct cleanup *old_cleanups;
2150 if (target_can_async_p ())
2151 run = xstrprintf ("%s %s&", cli_command, argc ? *argv : "");
2153 run = xstrprintf ("%s %s", cli_command, argc ? *argv : "");
2154 old_cleanups = make_cleanup (xfree, run);
2156 execute_command ( /*ui */ run, 0 /*from_tty */ );
2158 if (target_can_async_p ())
2160 /* If we're not executing, an exception should have been throw. */
2161 gdb_assert (is_running (inferior_ptid));
2162 do_cleanups (old_cleanups);
2166 /* Do this before doing any printing. It would appear that some
2167 print code leaves garbage around in the buffer. */
2168 do_cleanups (old_cleanups);
2173 mi_load_progress (const char *section_name,
2174 unsigned long sent_so_far,
2175 unsigned long total_section,
2176 unsigned long total_sent,
2177 unsigned long grand_total)
2179 struct timeval time_now, delta, update_threshold;
2180 static struct timeval last_update;
2181 static char *previous_sect_name = NULL;
2183 struct ui_out *saved_uiout;
2185 /* This function is called through deprecated_show_load_progress
2186 which means uiout may not be correct. Fix it for the duration
2187 of this function. */
2188 saved_uiout = uiout;
2190 if (current_interp_named_p (INTERP_MI)
2191 || current_interp_named_p (INTERP_MI2))
2192 uiout = mi_out_new (2);
2193 else if (current_interp_named_p (INTERP_MI1))
2194 uiout = mi_out_new (1);
2195 else if (current_interp_named_p (INTERP_MI3))
2196 uiout = mi_out_new (3);
2200 update_threshold.tv_sec = 0;
2201 update_threshold.tv_usec = 500000;
2202 gettimeofday (&time_now, NULL);
2204 delta.tv_usec = time_now.tv_usec - last_update.tv_usec;
2205 delta.tv_sec = time_now.tv_sec - last_update.tv_sec;
2207 if (delta.tv_usec < 0)
2210 delta.tv_usec += 1000000L;
2213 new_section = (previous_sect_name ?
2214 strcmp (previous_sect_name, section_name) : 1);
2217 struct cleanup *cleanup_tuple;
2219 xfree (previous_sect_name);
2220 previous_sect_name = xstrdup (section_name);
2223 fputs_unfiltered (current_token, raw_stdout);
2224 fputs_unfiltered ("+download", raw_stdout);
2225 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
2226 ui_out_field_string (uiout, "section", section_name);
2227 ui_out_field_int (uiout, "section-size", total_section);
2228 ui_out_field_int (uiout, "total-size", grand_total);
2229 do_cleanups (cleanup_tuple);
2230 mi_out_put (uiout, raw_stdout);
2231 fputs_unfiltered ("\n", raw_stdout);
2232 gdb_flush (raw_stdout);
2235 if (delta.tv_sec >= update_threshold.tv_sec &&
2236 delta.tv_usec >= update_threshold.tv_usec)
2238 struct cleanup *cleanup_tuple;
2240 last_update.tv_sec = time_now.tv_sec;
2241 last_update.tv_usec = time_now.tv_usec;
2243 fputs_unfiltered (current_token, raw_stdout);
2244 fputs_unfiltered ("+download", raw_stdout);
2245 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
2246 ui_out_field_string (uiout, "section", section_name);
2247 ui_out_field_int (uiout, "section-sent", sent_so_far);
2248 ui_out_field_int (uiout, "section-size", total_section);
2249 ui_out_field_int (uiout, "total-sent", total_sent);
2250 ui_out_field_int (uiout, "total-size", grand_total);
2251 do_cleanups (cleanup_tuple);
2252 mi_out_put (uiout, raw_stdout);
2253 fputs_unfiltered ("\n", raw_stdout);
2254 gdb_flush (raw_stdout);
2258 uiout = saved_uiout;
2262 timestamp (struct mi_timestamp *tv)
2264 gettimeofday (&tv->wallclock, NULL);
2265 #ifdef HAVE_GETRUSAGE
2266 getrusage (RUSAGE_SELF, &rusage);
2267 tv->utime.tv_sec = rusage.ru_utime.tv_sec;
2268 tv->utime.tv_usec = rusage.ru_utime.tv_usec;
2269 tv->stime.tv_sec = rusage.ru_stime.tv_sec;
2270 tv->stime.tv_usec = rusage.ru_stime.tv_usec;
2273 long usec = get_run_time ();
2275 tv->utime.tv_sec = usec/1000000L;
2276 tv->utime.tv_usec = usec - 1000000L*tv->utime.tv_sec;
2277 tv->stime.tv_sec = 0;
2278 tv->stime.tv_usec = 0;
2284 print_diff_now (struct mi_timestamp *start)
2286 struct mi_timestamp now;
2289 print_diff (start, &now);
2293 mi_print_timing_maybe (void)
2295 /* If the command is -enable-timing then do_timings may be
2296 true whilst current_command_ts is not initialized. */
2297 if (do_timings && current_command_ts)
2298 print_diff_now (current_command_ts);
2302 timeval_diff (struct timeval start, struct timeval end)
2304 return ((end.tv_sec - start.tv_sec) * 1000000L)
2305 + (end.tv_usec - start.tv_usec);
2309 print_diff (struct mi_timestamp *start, struct mi_timestamp *end)
2313 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
2314 timeval_diff (start->wallclock, end->wallclock) / 1000000.0,
2315 timeval_diff (start->utime, end->utime) / 1000000.0,
2316 timeval_diff (start->stime, end->stime) / 1000000.0);
2320 mi_cmd_trace_define_variable (char *command, char **argv, int argc)
2322 struct expression *expr;
2323 struct cleanup *back_to;
2324 LONGEST initval = 0;
2325 struct trace_state_variable *tsv;
2328 if (argc != 1 && argc != 2)
2329 error (_("Usage: -trace-define-variable VARIABLE [VALUE]"));
2331 expr = parse_expression (argv[0]);
2332 back_to = make_cleanup (xfree, expr);
2334 if (expr->nelts == 3 && expr->elts[0].opcode == OP_INTERNALVAR)
2336 struct internalvar *intvar = expr->elts[1].internalvar;
2339 name = internalvar_name (intvar);
2342 if (!name || *name == '\0')
2343 error (_("Invalid name of trace variable"));
2345 tsv = find_trace_state_variable (name);
2347 tsv = create_trace_state_variable (name);
2350 initval = value_as_long (parse_and_eval (argv[1]));
2352 tsv->initial_value = initval;
2354 do_cleanups (back_to);
2358 mi_cmd_trace_list_variables (char *command, char **argv, int argc)
2361 error (_("-trace-list-variables: no arguments are allowed"));
2363 tvariables_info_1 ();
2367 mi_cmd_trace_find (char *command, char **argv, int argc)
2372 error (_("trace selection mode is required"));
2376 if (strcmp (mode, "none") == 0)
2378 tfind_1 (tfind_number, -1, 0, 0, 0);
2382 if (current_trace_status ()->running)
2383 error (_("May not look at trace frames while trace is running."));
2385 if (strcmp (mode, "frame-number") == 0)
2388 error (_("frame number is required"));
2389 tfind_1 (tfind_number, atoi (argv[1]), 0, 0, 0);
2391 else if (strcmp (mode, "tracepoint-number") == 0)
2394 error (_("tracepoint number is required"));
2395 tfind_1 (tfind_tp, atoi (argv[1]), 0, 0, 0);
2397 else if (strcmp (mode, "pc") == 0)
2400 error (_("PC is required"));
2401 tfind_1 (tfind_pc, 0, parse_and_eval_address (argv[1]), 0, 0);
2403 else if (strcmp (mode, "pc-inside-range") == 0)
2406 error (_("Start and end PC are required"));
2407 tfind_1 (tfind_range, 0, parse_and_eval_address (argv[1]),
2408 parse_and_eval_address (argv[2]), 0);
2410 else if (strcmp (mode, "pc-outside-range") == 0)
2413 error (_("Start and end PC are required"));
2414 tfind_1 (tfind_outside, 0, parse_and_eval_address (argv[1]),
2415 parse_and_eval_address (argv[2]), 0);
2417 else if (strcmp (mode, "line") == 0)
2419 struct symtabs_and_lines sals;
2420 struct symtab_and_line sal;
2421 static CORE_ADDR start_pc, end_pc;
2422 struct cleanup *back_to;
2425 error (_("Line is required"));
2427 sals = decode_line_spec (argv[1], 1);
2428 back_to = make_cleanup (xfree, sals.sals);
2432 if (sal.symtab == 0)
2433 error (_("Could not find the specified line"));
2435 if (sal.line > 0 && find_line_pc_range (sal, &start_pc, &end_pc))
2436 tfind_1 (tfind_range, 0, start_pc, end_pc - 1, 0);
2438 error (_("Could not find the specified line"));
2440 do_cleanups (back_to);
2443 error (_("Invalid mode '%s'"), mode);
2445 if (has_stack_frames () || get_traceframe_number () >= 0)
2447 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
2452 mi_cmd_trace_save (char *command, char **argv, int argc)
2454 int target_saves = 0;
2457 if (argc != 1 && argc != 2)
2458 error (_("Usage: -trace-save [-r] filename"));
2463 if (strcmp (argv[0], "-r") == 0)
2466 error (_("Invalid option: %s"), argv[0]);
2473 trace_save (filename, target_saves);
2478 mi_cmd_trace_start (char *command, char **argv, int argc)
2484 mi_cmd_trace_status (char *command, char **argv, int argc)
2486 trace_status_mi (0);
2490 mi_cmd_trace_stop (char *command, char **argv, int argc)
2493 trace_status_mi (1);