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)
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)
508 if (argc != 0 && argc != 1)
509 error ("Invalid MI command");
512 thread = atoi (argv[0]);
514 print_thread_info (uiout, thread, -1);
517 struct collect_cores_data
525 collect_cores (struct thread_info *ti, void *xdata)
527 struct collect_cores_data *data = xdata;
529 if (ptid_get_pid (ti->ptid) == data->pid)
531 int core = target_core_of_thread (ti->ptid);
534 VEC_safe_push (int, data->cores, core);
541 unique (int *b, int *e)
551 struct print_one_inferior_data
554 VEC (int) *inferiors;
558 print_one_inferior (struct inferior *inferior, void *xdata)
560 struct print_one_inferior_data *top_data = xdata;
562 if (VEC_empty (int, top_data->inferiors)
563 || bsearch (&(inferior->pid), VEC_address (int, top_data->inferiors),
564 VEC_length (int, top_data->inferiors), sizeof (int),
565 compare_positive_ints))
567 struct collect_cores_data data;
568 struct cleanup *back_to
569 = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
571 ui_out_field_fmt (uiout, "id", "i%d", inferior->num);
572 ui_out_field_string (uiout, "type", "process");
573 if (inferior->pid != 0)
574 ui_out_field_int (uiout, "pid", inferior->pid);
576 if (inferior->pspace->ebfd)
578 ui_out_field_string (uiout, "executable",
579 bfd_get_filename (inferior->pspace->ebfd));
583 if (inferior->pid != 0)
585 data.pid = inferior->pid;
586 iterate_over_threads (collect_cores, &data);
589 if (!VEC_empty (int, data.cores))
592 struct cleanup *back_to_2 =
593 make_cleanup_ui_out_list_begin_end (uiout, "cores");
595 qsort (VEC_address (int, data.cores),
596 VEC_length (int, data.cores), sizeof (int),
597 compare_positive_ints);
599 b = VEC_address (int, data.cores);
600 e = b + VEC_length (int, data.cores);
604 ui_out_field_int (uiout, NULL, *b);
606 do_cleanups (back_to_2);
609 if (top_data->recurse)
610 print_thread_info (uiout, -1, inferior->pid);
612 do_cleanups (back_to);
618 /* Output a field named 'cores' with a list as the value. The elements of
619 the list are obtained by splitting 'cores' on comma. */
622 output_cores (struct ui_out *uiout, const char *field_name, const char *xcores)
624 struct cleanup *back_to = make_cleanup_ui_out_list_begin_end (uiout,
626 char *cores = xstrdup (xcores);
629 make_cleanup (xfree, cores);
631 for (p = strtok (p, ","); p; p = strtok (NULL, ","))
632 ui_out_field_string (uiout, NULL, p);
634 do_cleanups (back_to);
638 free_vector_of_ints (void *xvector)
640 VEC (int) **vector = xvector;
642 VEC_free (int, *vector);
646 do_nothing (splay_tree_key k)
651 free_vector_of_osdata_items (splay_tree_value xvalue)
653 VEC (osdata_item_s) *value = (VEC (osdata_item_s) *) xvalue;
655 /* We don't free the items itself, it will be done separately. */
656 VEC_free (osdata_item_s, value);
660 splay_tree_int_comparator (splay_tree_key xa, splay_tree_key xb)
669 free_splay_tree (void *xt)
672 splay_tree_delete (t);
676 list_available_thread_groups (VEC (int) *ids, int recurse)
679 struct osdata_item *item;
682 /* This keeps a map from integer (pid) to VEC (struct osdata_item *)*
683 The vector contains information about all threads for the given pid.
684 This is assigned an initial value to avoid "may be used uninitialized"
686 splay_tree tree = NULL;
688 /* get_osdata will throw if it cannot return data. */
689 data = get_osdata ("processes");
690 make_cleanup_osdata_free (data);
694 struct osdata *threads = get_osdata ("threads");
696 make_cleanup_osdata_free (threads);
697 tree = splay_tree_new (splay_tree_int_comparator,
699 free_vector_of_osdata_items);
700 make_cleanup (free_splay_tree, tree);
703 VEC_iterate (osdata_item_s, threads->items,
707 const char *pid = get_osdata_column (item, "pid");
708 int pid_i = strtoul (pid, NULL, 0);
709 VEC (osdata_item_s) *vec = 0;
711 splay_tree_node n = splay_tree_lookup (tree, pid_i);
714 VEC_safe_push (osdata_item_s, vec, item);
715 splay_tree_insert (tree, pid_i, (splay_tree_value)vec);
719 vec = (VEC (osdata_item_s) *) n->value;
720 VEC_safe_push (osdata_item_s, vec, item);
721 n->value = (splay_tree_value) vec;
726 make_cleanup_ui_out_list_begin_end (uiout, "groups");
729 VEC_iterate (osdata_item_s, data->items,
733 struct cleanup *back_to;
735 const char *pid = get_osdata_column (item, "pid");
736 const char *cmd = get_osdata_column (item, "command");
737 const char *user = get_osdata_column (item, "user");
738 const char *cores = get_osdata_column (item, "cores");
740 int pid_i = strtoul (pid, NULL, 0);
742 /* At present, the target will return all available processes
743 and if information about specific ones was required, we filter
744 undesired processes here. */
745 if (ids && bsearch (&pid_i, VEC_address (int, ids),
746 VEC_length (int, ids),
747 sizeof (int), compare_positive_ints) == NULL)
751 back_to = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
753 ui_out_field_fmt (uiout, "id", "%s", pid);
754 ui_out_field_string (uiout, "type", "process");
756 ui_out_field_string (uiout, "description", cmd);
758 ui_out_field_string (uiout, "user", user);
760 output_cores (uiout, "cores", cores);
764 splay_tree_node n = splay_tree_lookup (tree, pid_i);
767 VEC (osdata_item_s) *children = (VEC (osdata_item_s) *) n->value;
768 struct osdata_item *child;
771 make_cleanup_ui_out_list_begin_end (uiout, "threads");
774 VEC_iterate (osdata_item_s, children, ix_child, child);
777 struct cleanup *back_to_2 =
778 make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
779 const char *tid = get_osdata_column (child, "tid");
780 const char *tcore = get_osdata_column (child, "core");
782 ui_out_field_string (uiout, "id", tid);
784 ui_out_field_string (uiout, "core", tcore);
786 do_cleanups (back_to_2);
791 do_cleanups (back_to);
796 mi_cmd_list_thread_groups (char *command, char **argv, int argc)
798 struct cleanup *back_to;
805 AVAILABLE_OPT, RECURSE_OPT
807 static struct mi_opt opts[] =
809 {"-available", AVAILABLE_OPT, 0},
810 {"-recurse", RECURSE_OPT, 1},
819 int opt = mi_getopt ("-list-thread-groups", argc, argv, opts,
824 switch ((enum opt) opt)
830 if (strcmp (optarg, "0") == 0)
832 else if (strcmp (optarg, "1") == 0)
835 error ("only '0' and '1' are valid values "
836 "for the '--recurse' option");
841 for (; optind < argc; ++optind)
846 if (*(argv[optind]) != 'i')
847 error ("invalid syntax of group id '%s'", argv[optind]);
849 inf = strtoul (argv[optind] + 1, &end, 0);
852 error ("invalid syntax of group id '%s'", argv[optind]);
853 VEC_safe_push (int, ids, inf);
855 if (VEC_length (int, ids) > 1)
856 qsort (VEC_address (int, ids),
857 VEC_length (int, ids),
858 sizeof (int), compare_positive_ints);
860 back_to = make_cleanup (free_vector_of_ints, &ids);
864 list_available_thread_groups (ids, recurse);
866 else if (VEC_length (int, ids) == 1)
868 /* Local thread groups, single id. */
869 int id = *VEC_address (int, ids);
870 struct inferior *inf = find_inferior_id (id);
873 error ("Non-existent thread group id '%d'", id);
875 print_thread_info (uiout, -1, inf->pid);
879 struct print_one_inferior_data data;
881 data.recurse = recurse;
882 data.inferiors = ids;
884 /* Local thread groups. Either no explicit ids -- and we
885 print everything, or several explicit ids. In both cases,
886 we print more than one group, and have to use 'groups'
887 as the top-level element. */
888 make_cleanup_ui_out_list_begin_end (uiout, "groups");
889 update_thread_list ();
890 iterate_over_inferiors (print_one_inferior, &data);
893 do_cleanups (back_to);
897 mi_cmd_data_list_register_names (char *command, char **argv, int argc)
899 struct gdbarch *gdbarch;
902 struct cleanup *cleanup;
904 /* Note that the test for a valid register must include checking the
905 gdbarch_register_name because gdbarch_num_regs may be allocated for
906 the union of the register sets within a family of related processors.
907 In this case, some entries of gdbarch_register_name will change depending
908 upon the particular processor being debugged. */
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 regcache *prev_regs;
952 struct gdbarch *gdbarch;
953 int regnum, numregs, changed;
955 struct cleanup *cleanup;
957 /* The last time we visited this function, the current frame's register
958 contents were saved in THIS_REGS. Move THIS_REGS over to PREV_REGS,
959 and refresh THIS_REGS with the now-current register contents. */
961 prev_regs = this_regs;
962 this_regs = frame_save_as_regcache (get_selected_frame (NULL));
963 cleanup = make_cleanup_regcache_xfree (prev_regs);
965 /* Note that the test for a valid register must include checking the
966 gdbarch_register_name because gdbarch_num_regs may be allocated for
967 the union of the register sets within a family of related processors.
968 In this case, some entries of gdbarch_register_name will change depending
969 upon the particular processor being debugged. */
971 gdbarch = get_regcache_arch (this_regs);
972 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
974 make_cleanup_ui_out_list_begin_end (uiout, "changed-registers");
976 if (argc == 0) /* No args, just do all the regs. */
982 if (gdbarch_register_name (gdbarch, regnum) == NULL
983 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
985 changed = register_changed_p (regnum, prev_regs, this_regs);
987 error ("-data-list-changed-registers: "
988 "Unable to read register contents.");
990 ui_out_field_int (uiout, NULL, regnum);
994 /* Else, list of register #s, just do listed regs. */
995 for (i = 0; i < argc; i++)
997 regnum = atoi (argv[i]);
1001 && gdbarch_register_name (gdbarch, regnum) != NULL
1002 && *gdbarch_register_name (gdbarch, regnum) != '\000')
1004 changed = register_changed_p (regnum, prev_regs, this_regs);
1006 error ("-data-list-changed-registers: "
1007 "Unable to read register contents.");
1009 ui_out_field_int (uiout, NULL, regnum);
1012 error ("bad register number");
1014 do_cleanups (cleanup);
1018 register_changed_p (int regnum, struct regcache *prev_regs,
1019 struct regcache *this_regs)
1021 struct gdbarch *gdbarch = get_regcache_arch (this_regs);
1022 gdb_byte prev_buffer[MAX_REGISTER_SIZE];
1023 gdb_byte this_buffer[MAX_REGISTER_SIZE];
1025 /* Registers not valid in this frame return count as unchanged. */
1026 if (regcache_register_status (this_regs, regnum) == REG_UNKNOWN)
1029 /* First time through or after gdbarch change consider all registers as
1030 changed. Same for registers not valid in the previous frame. */
1031 if (!prev_regs || get_regcache_arch (prev_regs) != gdbarch
1032 || regcache_register_status (prev_regs, regnum) == REG_UNKNOWN)
1035 /* Get register contents and compare. */
1036 regcache_cooked_read (prev_regs, regnum, prev_buffer);
1037 regcache_cooked_read (this_regs, regnum, this_buffer);
1039 return memcmp (prev_buffer, this_buffer,
1040 register_size (gdbarch, regnum)) != 0;
1043 /* Return a list of register number and value pairs. The valid
1044 arguments expected are: a letter indicating the format in which to
1045 display the registers contents. This can be one of: x (hexadecimal), d
1046 (decimal), N (natural), t (binary), o (octal), r (raw). After the
1047 format argumetn there can be a sequence of numbers, indicating which
1048 registers to fetch the content of. If the format is the only argument,
1049 a list of all the registers with their values is returned. */
1051 mi_cmd_data_list_register_values (char *command, char **argv, int argc)
1053 struct frame_info *frame;
1054 struct gdbarch *gdbarch;
1055 int regnum, numregs, format;
1057 struct cleanup *list_cleanup, *tuple_cleanup;
1059 /* Note that the test for a valid register must include checking the
1060 gdbarch_register_name because gdbarch_num_regs may be allocated for
1061 the union of the register sets within a family of related processors.
1062 In this case, some entries of gdbarch_register_name will change depending
1063 upon the particular processor being debugged. */
1066 error ("-data-list-register-values: Usage: "
1067 "-data-list-register-values <format> [<regnum1>...<regnumN>]");
1069 format = (int) argv[0][0];
1071 frame = get_selected_frame (NULL);
1072 gdbarch = get_frame_arch (frame);
1073 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
1075 list_cleanup = make_cleanup_ui_out_list_begin_end (uiout, "register-values");
1077 if (argc == 1) /* No args, beside the format: do all the regs. */
1083 if (gdbarch_register_name (gdbarch, regnum) == NULL
1084 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
1086 tuple_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1087 ui_out_field_int (uiout, "number", regnum);
1088 get_register (frame, regnum, format);
1089 do_cleanups (tuple_cleanup);
1093 /* Else, list of register #s, just do listed regs. */
1094 for (i = 1; i < argc; i++)
1096 regnum = atoi (argv[i]);
1100 && gdbarch_register_name (gdbarch, regnum) != NULL
1101 && *gdbarch_register_name (gdbarch, regnum) != '\000')
1103 tuple_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1104 ui_out_field_int (uiout, "number", regnum);
1105 get_register (frame, regnum, format);
1106 do_cleanups (tuple_cleanup);
1109 error ("bad register number");
1111 do_cleanups (list_cleanup);
1114 /* Output one register's contents in the desired format. */
1116 get_register (struct frame_info *frame, int regnum, int format)
1118 struct gdbarch *gdbarch = get_frame_arch (frame);
1120 enum lval_type lval;
1121 static struct ui_stream *stb = NULL;
1124 stb = ui_out_stream_new (uiout);
1129 val = get_frame_register_value (frame, regnum);
1131 if (value_optimized_out (val))
1132 error ("Optimized out");
1137 char *ptr, buf[1024];
1138 const gdb_byte *valaddr = value_contents_for_printing (val);
1142 for (j = 0; j < register_size (gdbarch, regnum); j++)
1144 int idx = gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG ?
1145 j : register_size (gdbarch, regnum) - 1 - j;
1147 sprintf (ptr, "%02x", (unsigned char) valaddr[idx]);
1150 ui_out_field_string (uiout, "value", buf);
1151 /*fputs_filtered (buf, gdb_stdout); */
1155 struct value_print_options opts;
1157 get_formatted_print_options (&opts, format);
1159 val_print (value_type (val),
1160 value_contents_for_printing (val),
1161 value_embedded_offset (val), 0,
1162 stb->stream, 0, val, &opts, current_language);
1163 ui_out_field_stream (uiout, "value", stb);
1164 ui_out_stream_delete (stb);
1168 /* Write given values into registers. The registers and values are
1169 given as pairs. The corresponding MI command is
1170 -data-write-register-values <format>
1171 [<regnum1> <value1>...<regnumN> <valueN>] */
1173 mi_cmd_data_write_register_values (char *command, char **argv, int argc)
1175 struct regcache *regcache;
1176 struct gdbarch *gdbarch;
1180 /* Note that the test for a valid register must include checking the
1181 gdbarch_register_name because gdbarch_num_regs may be allocated for
1182 the union of the register sets within a family of related processors.
1183 In this case, some entries of gdbarch_register_name will change depending
1184 upon the particular processor being debugged. */
1186 regcache = get_current_regcache ();
1187 gdbarch = get_regcache_arch (regcache);
1188 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
1191 error ("-data-write-register-values: Usage: -data-write-register-"
1192 "values <format> [<regnum1> <value1>...<regnumN> <valueN>]");
1194 format = (int) argv[0][0];
1196 if (!target_has_registers)
1197 error ("-data-write-register-values: No registers.");
1200 error ("-data-write-register-values: No regs and values specified.");
1203 error ("-data-write-register-values: "
1204 "Regs and vals are not in pairs.");
1206 for (i = 1; i < argc; i = i + 2)
1208 int regnum = atoi (argv[i]);
1210 if (regnum >= 0 && regnum < numregs
1211 && gdbarch_register_name (gdbarch, regnum)
1212 && *gdbarch_register_name (gdbarch, regnum))
1216 /* Get the value as a number. */
1217 value = parse_and_eval_address (argv[i + 1]);
1219 /* Write it down. */
1220 regcache_cooked_write_signed (regcache, regnum, value);
1223 error ("bad register number");
1227 /* Evaluate the value of the argument. The argument is an
1228 expression. If the expression contains spaces it needs to be
1229 included in double quotes. */
1231 mi_cmd_data_evaluate_expression (char *command, char **argv, int argc)
1233 struct expression *expr;
1234 struct cleanup *old_chain = NULL;
1236 struct ui_stream *stb = NULL;
1237 struct value_print_options opts;
1239 stb = ui_out_stream_new (uiout);
1243 ui_out_stream_delete (stb);
1244 error ("-data-evaluate-expression: "
1245 "Usage: -data-evaluate-expression expression");
1248 expr = parse_expression (argv[0]);
1250 old_chain = make_cleanup (free_current_contents, &expr);
1252 val = evaluate_expression (expr);
1254 /* Print the result of the expression evaluation. */
1255 get_user_print_options (&opts);
1257 common_val_print (val, stb->stream, 0, &opts, current_language);
1259 ui_out_field_stream (uiout, "value", stb);
1260 ui_out_stream_delete (stb);
1262 do_cleanups (old_chain);
1265 /* DATA-MEMORY-READ:
1267 ADDR: start address of data to be dumped.
1268 WORD-FORMAT: a char indicating format for the ``word''. See
1270 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
1271 NR_ROW: Number of rows.
1272 NR_COL: The number of colums (words per row).
1273 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
1274 ASCHAR for unprintable characters.
1276 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
1277 displayes them. Returns:
1279 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
1282 The number of bytes read is SIZE*ROW*COL. */
1285 mi_cmd_data_read_memory (char *command, char **argv, int argc)
1287 struct gdbarch *gdbarch = get_current_arch ();
1288 struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
1294 struct type *word_type;
1307 static struct mi_opt opts[] =
1309 {"o", OFFSET_OPT, 1},
1315 int opt = mi_getopt ("-data-read-memory", argc, argv, opts,
1320 switch ((enum opt) opt)
1323 offset = atol (optarg);
1330 if (argc < 5 || argc > 6)
1331 error ("-data-read-memory: Usage: "
1332 "ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR].");
1334 /* Extract all the arguments. */
1336 /* Start address of the memory dump. */
1337 addr = parse_and_eval_address (argv[0]) + offset;
1338 /* The format character to use when displaying a memory word. See
1339 the ``x'' command. */
1340 word_format = argv[1][0];
1341 /* The size of the memory word. */
1342 word_size = atol (argv[2]);
1346 word_type = builtin_type (gdbarch)->builtin_int8;
1350 word_type = builtin_type (gdbarch)->builtin_int16;
1354 word_type = builtin_type (gdbarch)->builtin_int32;
1358 word_type = builtin_type (gdbarch)->builtin_int64;
1362 word_type = builtin_type (gdbarch)->builtin_int8;
1365 /* The number of rows. */
1366 nr_rows = atol (argv[3]);
1368 error ("-data-read-memory: invalid number of rows.");
1370 /* Number of bytes per row. */
1371 nr_cols = atol (argv[4]);
1373 error ("-data-read-memory: invalid number of columns.");
1375 /* The un-printable character when printing ascii. */
1381 /* Create a buffer and read it in. */
1382 total_bytes = word_size * nr_rows * nr_cols;
1383 mbuf = xcalloc (total_bytes, 1);
1384 make_cleanup (xfree, mbuf);
1386 /* Dispatch memory reads to the topmost target, not the flattened
1388 nr_bytes = target_read (current_target.beneath,
1389 TARGET_OBJECT_MEMORY, NULL, mbuf,
1392 error ("Unable to read memory.");
1394 /* Output the header information. */
1395 ui_out_field_core_addr (uiout, "addr", gdbarch, addr);
1396 ui_out_field_int (uiout, "nr-bytes", nr_bytes);
1397 ui_out_field_int (uiout, "total-bytes", total_bytes);
1398 ui_out_field_core_addr (uiout, "next-row",
1399 gdbarch, addr + word_size * nr_cols);
1400 ui_out_field_core_addr (uiout, "prev-row",
1401 gdbarch, addr - word_size * nr_cols);
1402 ui_out_field_core_addr (uiout, "next-page", gdbarch, addr + total_bytes);
1403 ui_out_field_core_addr (uiout, "prev-page", gdbarch, addr - total_bytes);
1405 /* Build the result as a two dimentional table. */
1407 struct ui_stream *stream = ui_out_stream_new (uiout);
1408 struct cleanup *cleanup_list_memory;
1412 cleanup_list_memory = make_cleanup_ui_out_list_begin_end (uiout, "memory");
1413 for (row = 0, row_byte = 0;
1415 row++, row_byte += nr_cols * word_size)
1419 struct cleanup *cleanup_tuple;
1420 struct cleanup *cleanup_list_data;
1421 struct value_print_options opts;
1423 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1424 ui_out_field_core_addr (uiout, "addr", gdbarch, addr + row_byte);
1425 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr +
1427 cleanup_list_data = make_cleanup_ui_out_list_begin_end (uiout, "data");
1428 get_formatted_print_options (&opts, word_format);
1429 for (col = 0, col_byte = row_byte;
1431 col++, col_byte += word_size)
1433 if (col_byte + word_size > nr_bytes)
1435 ui_out_field_string (uiout, NULL, "N/A");
1439 ui_file_rewind (stream->stream);
1440 print_scalar_formatted (mbuf + col_byte, word_type, &opts,
1441 word_asize, stream->stream);
1442 ui_out_field_stream (uiout, NULL, stream);
1445 do_cleanups (cleanup_list_data);
1450 ui_file_rewind (stream->stream);
1451 for (byte = row_byte;
1452 byte < row_byte + word_size * nr_cols; byte++)
1454 if (byte >= nr_bytes)
1456 fputc_unfiltered ('X', stream->stream);
1458 else if (mbuf[byte] < 32 || mbuf[byte] > 126)
1460 fputc_unfiltered (aschar, stream->stream);
1463 fputc_unfiltered (mbuf[byte], stream->stream);
1465 ui_out_field_stream (uiout, "ascii", stream);
1467 do_cleanups (cleanup_tuple);
1469 ui_out_stream_delete (stream);
1470 do_cleanups (cleanup_list_memory);
1472 do_cleanups (cleanups);
1476 mi_cmd_data_read_memory_bytes (char *command, char **argv, int argc)
1478 struct gdbarch *gdbarch = get_current_arch ();
1479 struct cleanup *cleanups;
1482 memory_read_result_s *read_result;
1484 VEC(memory_read_result_s) *result;
1492 static struct mi_opt opts[] =
1494 {"o", OFFSET_OPT, 1},
1500 int opt = mi_getopt ("-data-read-memory-bytes", argc, argv, opts,
1504 switch ((enum opt) opt)
1507 offset = atol (optarg);
1515 error ("Usage: [ -o OFFSET ] ADDR LENGTH.");
1517 addr = parse_and_eval_address (argv[0]) + offset;
1518 length = atol (argv[1]);
1520 result = read_memory_robust (current_target.beneath, addr, length);
1522 cleanups = make_cleanup (free_memory_read_result_vector, result);
1524 if (VEC_length (memory_read_result_s, result) == 0)
1525 error ("Unable to read memory.");
1527 make_cleanup_ui_out_list_begin_end (uiout, "memory");
1529 VEC_iterate (memory_read_result_s, result, ix, read_result);
1532 struct cleanup *t = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1536 ui_out_field_core_addr (uiout, "begin", gdbarch, read_result->begin);
1537 ui_out_field_core_addr (uiout, "offset", gdbarch, read_result->begin
1539 ui_out_field_core_addr (uiout, "end", gdbarch, read_result->end);
1541 data = xmalloc ((read_result->end - read_result->begin) * 2 + 1);
1543 for (i = 0, p = data;
1544 i < (read_result->end - read_result->begin);
1547 sprintf (p, "%02x", read_result->data[i]);
1549 ui_out_field_string (uiout, "contents", data);
1553 do_cleanups (cleanups);
1557 /* DATA-MEMORY-WRITE:
1559 COLUMN_OFFSET: optional argument. Must be preceeded by '-o'. The
1560 offset from the beginning of the memory grid row where the cell to
1562 ADDR: start address of the row in the memory grid where the memory
1563 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
1564 the location to write to.
1565 FORMAT: a char indicating format for the ``word''. See
1567 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
1568 VALUE: value to be written into the memory address.
1570 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1574 mi_cmd_data_write_memory (char *command, char **argv, int argc)
1576 struct gdbarch *gdbarch = get_current_arch ();
1577 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1581 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1582 enough when using a compiler other than GCC. */
1585 struct cleanup *old_chain;
1593 static struct mi_opt opts[] =
1595 {"o", OFFSET_OPT, 1},
1601 int opt = mi_getopt ("-data-write-memory", argc, argv, opts,
1606 switch ((enum opt) opt)
1609 offset = atol (optarg);
1617 error ("-data-write-memory: Usage: "
1618 "[-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE.");
1620 /* Extract all the arguments. */
1621 /* Start address of the memory dump. */
1622 addr = parse_and_eval_address (argv[0]);
1623 /* The format character to use when displaying a memory word. See
1624 the ``x'' command. */
1625 word_format = argv[1][0];
1626 /* The size of the memory word. */
1627 word_size = atol (argv[2]);
1629 /* Calculate the real address of the write destination. */
1630 addr += (offset * word_size);
1632 /* Get the value as a number. */
1633 value = parse_and_eval_address (argv[3]);
1634 /* Get the value into an array. */
1635 buffer = xmalloc (word_size);
1636 old_chain = make_cleanup (xfree, buffer);
1637 store_signed_integer (buffer, word_size, byte_order, value);
1638 /* Write it down to memory. */
1639 write_memory (addr, buffer, word_size);
1640 /* Free the buffer. */
1641 do_cleanups (old_chain);
1644 /* DATA-MEMORY-WRITE-RAW:
1647 DATA: string of bytes to write at that address. */
1649 mi_cmd_data_write_memory_bytes (char *command, char **argv, int argc)
1655 struct cleanup *back_to;
1658 error ("Usage: ADDR DATA.");
1660 addr = parse_and_eval_address (argv[0]);
1662 len = strlen (cdata)/2;
1664 data = xmalloc (len);
1665 back_to = make_cleanup (xfree, data);
1667 for (i = 0; i < len; ++i)
1670 sscanf (cdata + i * 2, "%02x", &x);
1671 data[i] = (gdb_byte)x;
1674 r = target_write_memory (addr, data, len);
1676 error (_("Could not write memory"));
1678 do_cleanups (back_to);
1683 mi_cmd_enable_timings (char *command, char **argv, int argc)
1689 if (strcmp (argv[0], "yes") == 0)
1691 else if (strcmp (argv[0], "no") == 0)
1702 error ("-enable-timings: Usage: %s {yes|no}", command);
1706 mi_cmd_list_features (char *command, char **argv, int argc)
1710 struct cleanup *cleanup = NULL;
1712 cleanup = make_cleanup_ui_out_list_begin_end (uiout, "features");
1713 ui_out_field_string (uiout, NULL, "frozen-varobjs");
1714 ui_out_field_string (uiout, NULL, "pending-breakpoints");
1715 ui_out_field_string (uiout, NULL, "thread-info");
1716 ui_out_field_string (uiout, NULL, "data-read-memory-bytes");
1719 ui_out_field_string (uiout, NULL, "python");
1722 do_cleanups (cleanup);
1726 error ("-list-features should be passed no arguments");
1730 mi_cmd_list_target_features (char *command, char **argv, int argc)
1734 struct cleanup *cleanup = NULL;
1736 cleanup = make_cleanup_ui_out_list_begin_end (uiout, "features");
1737 if (target_can_async_p ())
1738 ui_out_field_string (uiout, NULL, "async");
1739 if (target_can_execute_reverse)
1740 ui_out_field_string (uiout, NULL, "reverse");
1742 do_cleanups (cleanup);
1746 error ("-list-target-features should be passed no arguments");
1750 mi_cmd_add_inferior (char *command, char **argv, int argc)
1752 struct inferior *inf;
1755 error (_("-add-inferior should be passed no arguments"));
1757 inf = add_inferior_with_spaces ();
1759 ui_out_field_fmt (uiout, "inferior", "i%d", inf->num);
1762 /* Callback used to find the first inferior other than the
1766 get_other_inferior (struct inferior *inf, void *arg)
1768 if (inf == current_inferior ())
1775 mi_cmd_remove_inferior (char *command, char **argv, int argc)
1778 struct inferior *inf;
1781 error ("-remove-inferior should be passed a single argument");
1783 if (sscanf (argv[0], "i%d", &id) != 1)
1784 error ("the thread group id is syntactically invalid");
1786 inf = find_inferior_id (id);
1788 error ("the specified thread group does not exist");
1791 error (_("cannot remove an active inferior"));
1793 if (inf == current_inferior ())
1795 struct thread_info *tp = 0;
1796 struct inferior *new_inferior
1797 = iterate_over_inferiors (get_other_inferior, NULL);
1799 if (new_inferior == NULL)
1800 error (_("Cannot remove last inferior"));
1802 set_current_inferior (new_inferior);
1803 if (new_inferior->pid != 0)
1804 tp = any_thread_of_process (new_inferior->pid);
1805 switch_to_thread (tp ? tp->ptid : null_ptid);
1806 set_current_program_space (new_inferior->pspace);
1809 delete_inferior_1 (inf, 1 /* silent */);
1814 /* Execute a command within a safe environment.
1815 Return <0 for error; >=0 for ok.
1817 args->action will tell mi_execute_command what action
1818 to perfrom after the given command has executed (display/suppress
1819 prompt, display error). */
1822 captured_mi_execute_command (struct ui_out *uiout, void *data)
1824 struct cleanup *cleanup;
1825 struct mi_parse *context = (struct mi_parse *) data;
1828 current_command_ts = context->cmd_start;
1830 current_token = xstrdup (context->token);
1831 cleanup = make_cleanup (free_current_contents, ¤t_token);
1833 running_result_record_printed = 0;
1835 switch (context->op)
1838 /* A MI command was read from the input stream. */
1840 /* FIXME: gdb_???? */
1841 fprintf_unfiltered (raw_stdout, " token=`%s' command=`%s' args=`%s'\n",
1842 context->token, context->command, context->args);
1845 mi_cmd_execute (context);
1847 /* Print the result if there were no errors.
1849 Remember that on the way out of executing a command, you have
1850 to directly use the mi_interp's uiout, since the command could
1851 have reset the interpreter, in which case the current uiout
1852 will most likely crash in the mi_out_* routines. */
1853 if (!running_result_record_printed)
1855 fputs_unfiltered (context->token, raw_stdout);
1856 /* There's no particularly good reason why target-connect results
1857 in not ^done. Should kill ^connected for MI3. */
1858 fputs_unfiltered (strcmp (context->command, "target-select") == 0
1859 ? "^connected" : "^done", raw_stdout);
1860 mi_out_put (uiout, raw_stdout);
1861 mi_out_rewind (uiout);
1862 mi_print_timing_maybe ();
1863 fputs_unfiltered ("\n", raw_stdout);
1866 /* The command does not want anything to be printed. In that
1867 case, the command probably should not have written anything
1868 to uiout, but in case it has written something, discard it. */
1869 mi_out_rewind (uiout);
1876 /* A CLI command was read from the input stream. */
1877 /* This "feature" will be removed as soon as we have a
1878 complete set of mi commands. */
1879 /* Echo the command on the console. */
1880 fprintf_unfiltered (gdb_stdlog, "%s\n", context->command);
1881 /* Call the "console" interpreter. */
1882 argv[0] = "console";
1883 argv[1] = context->command;
1884 mi_cmd_interpreter_exec ("-interpreter-exec", argv, 2);
1886 /* If we changed interpreters, DON'T print out anything. */
1887 if (current_interp_named_p (INTERP_MI)
1888 || current_interp_named_p (INTERP_MI1)
1889 || current_interp_named_p (INTERP_MI2)
1890 || current_interp_named_p (INTERP_MI3))
1892 if (!running_result_record_printed)
1894 fputs_unfiltered (context->token, raw_stdout);
1895 fputs_unfiltered ("^done", raw_stdout);
1896 mi_out_put (uiout, raw_stdout);
1897 mi_out_rewind (uiout);
1898 mi_print_timing_maybe ();
1899 fputs_unfiltered ("\n", raw_stdout);
1902 mi_out_rewind (uiout);
1909 do_cleanups (cleanup);
1914 /* Print a gdb exception to the MI output stream. */
1917 mi_print_exception (const char *token, struct gdb_exception exception)
1919 fputs_unfiltered (token, raw_stdout);
1920 fputs_unfiltered ("^error,msg=\"", raw_stdout);
1921 if (exception.message == NULL)
1922 fputs_unfiltered ("unknown error", raw_stdout);
1924 fputstr_unfiltered (exception.message, '"', raw_stdout);
1925 fputs_unfiltered ("\"\n", raw_stdout);
1929 mi_execute_command (char *cmd, int from_tty)
1932 struct mi_parse *command = NULL;
1933 volatile struct gdb_exception exception;
1935 /* This is to handle EOF (^D). We just quit gdb. */
1936 /* FIXME: we should call some API function here. */
1938 quit_force (NULL, from_tty);
1940 target_log_command (cmd);
1942 TRY_CATCH (exception, RETURN_MASK_ALL)
1944 command = mi_parse (cmd, &token);
1946 if (exception.reason < 0)
1948 mi_print_exception (token, exception);
1953 struct gdb_exception result;
1954 ptid_t previous_ptid = inferior_ptid;
1956 command->token = token;
1960 command->cmd_start = (struct mi_timestamp *)
1961 xmalloc (sizeof (struct mi_timestamp));
1962 timestamp (command->cmd_start);
1965 result = catch_exception (uiout, captured_mi_execute_command, command,
1967 if (result.reason < 0)
1969 /* The command execution failed and error() was called
1971 mi_print_exception (command->token, result);
1972 mi_out_rewind (uiout);
1975 bpstat_do_actions ();
1977 if (/* The notifications are only output when the top-level
1978 interpreter (specified on the command line) is MI. */
1979 ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ()))
1980 /* Don't try report anything if there are no threads --
1981 the program is dead. */
1982 && thread_count () != 0
1983 /* -thread-select explicitly changes thread. If frontend uses that
1984 internally, we don't want to emit =thread-selected, since
1985 =thread-selected is supposed to indicate user's intentions. */
1986 && strcmp (command->command, "thread-select") != 0)
1988 struct mi_interp *mi = top_level_interpreter_data ();
1989 int report_change = 0;
1991 if (command->thread == -1)
1993 report_change = (!ptid_equal (previous_ptid, null_ptid)
1994 && !ptid_equal (inferior_ptid, previous_ptid)
1995 && !ptid_equal (inferior_ptid, null_ptid));
1997 else if (!ptid_equal (inferior_ptid, null_ptid))
1999 struct thread_info *ti = inferior_thread ();
2001 report_change = (ti->num != command->thread);
2006 struct thread_info *ti = inferior_thread ();
2008 target_terminal_ours ();
2009 fprintf_unfiltered (mi->event_channel,
2010 "thread-selected,id=\"%d\"",
2012 gdb_flush (mi->event_channel);
2016 mi_parse_free (command);
2019 fputs_unfiltered ("(gdb) \n", raw_stdout);
2020 gdb_flush (raw_stdout);
2021 /* Print any buffered hook code. */
2026 mi_cmd_execute (struct mi_parse *parse)
2028 struct cleanup *cleanup;
2030 prepare_execute_command ();
2032 cleanup = make_cleanup (null_cleanup, NULL);
2034 if (parse->all && parse->thread_group != -1)
2035 error (_("Cannot specify --thread-group together with --all"));
2037 if (parse->all && parse->thread != -1)
2038 error (_("Cannot specify --thread together with --all"));
2040 if (parse->thread_group != -1 && parse->thread != -1)
2041 error (_("Cannot specify --thread together with --thread-group"));
2043 if (parse->frame != -1 && parse->thread == -1)
2044 error (_("Cannot specify --frame without --thread"));
2046 if (parse->thread_group != -1)
2048 struct inferior *inf = find_inferior_id (parse->thread_group);
2049 struct thread_info *tp = 0;
2052 error (_("Invalid thread group for the --thread-group option"));
2054 set_current_inferior (inf);
2055 /* This behaviour means that if --thread-group option identifies
2056 an inferior with multiple threads, then a random one will be picked.
2057 This is not a problem -- frontend should always provide --thread if
2058 it wishes to operate on a specific thread. */
2060 tp = any_thread_of_process (inf->pid);
2061 switch_to_thread (tp ? tp->ptid : null_ptid);
2062 set_current_program_space (inf->pspace);
2065 if (parse->thread != -1)
2067 struct thread_info *tp = find_thread_id (parse->thread);
2070 error (_("Invalid thread id: %d"), parse->thread);
2072 if (is_exited (tp->ptid))
2073 error (_("Thread id: %d has terminated"), parse->thread);
2075 switch_to_thread (tp->ptid);
2078 if (parse->frame != -1)
2080 struct frame_info *fid;
2081 int frame = parse->frame;
2083 fid = find_relative_frame (get_current_frame (), &frame);
2085 /* find_relative_frame was successful */
2088 error (_("Invalid frame id: %d"), frame);
2091 current_context = parse;
2093 if (parse->cmd->argv_func != NULL)
2094 parse->cmd->argv_func (parse->command, parse->argv, parse->argc);
2095 else if (parse->cmd->cli.cmd != 0)
2097 /* FIXME: DELETE THIS. */
2098 /* The operation is still implemented by a cli command. */
2099 /* Must be a synchronous one. */
2100 mi_execute_cli_command (parse->cmd->cli.cmd, parse->cmd->cli.args_p,
2105 /* FIXME: DELETE THIS. */
2106 struct ui_file *stb;
2108 stb = mem_fileopen ();
2110 fputs_unfiltered ("Undefined mi command: ", stb);
2111 fputstr_unfiltered (parse->command, '"', stb);
2112 fputs_unfiltered (" (missing implementation)", stb);
2114 make_cleanup_ui_file_delete (stb);
2117 do_cleanups (cleanup);
2120 /* FIXME: This is just a hack so we can get some extra commands going.
2121 We don't want to channel things through the CLI, but call libgdb directly.
2122 Use only for synchronous commands. */
2125 mi_execute_cli_command (const char *cmd, int args_p, const char *args)
2129 struct cleanup *old_cleanups;
2133 run = xstrprintf ("%s %s", cmd, args);
2135 run = xstrdup (cmd);
2137 /* FIXME: gdb_???? */
2138 fprintf_unfiltered (gdb_stdout, "cli=%s run=%s\n",
2140 old_cleanups = make_cleanup (xfree, run);
2141 execute_command ( /*ui */ run, 0 /*from_tty */ );
2142 do_cleanups (old_cleanups);
2148 mi_execute_async_cli_command (char *cli_command, char **argv, int argc)
2150 struct cleanup *old_cleanups;
2153 if (target_can_async_p ())
2154 run = xstrprintf ("%s %s&", cli_command, argc ? *argv : "");
2156 run = xstrprintf ("%s %s", cli_command, argc ? *argv : "");
2157 old_cleanups = make_cleanup (xfree, run);
2159 execute_command ( /*ui */ run, 0 /*from_tty */ );
2161 if (target_can_async_p ())
2163 /* If we're not executing, an exception should have been throw. */
2164 gdb_assert (is_running (inferior_ptid));
2165 do_cleanups (old_cleanups);
2169 /* Do this before doing any printing. It would appear that some
2170 print code leaves garbage around in the buffer. */
2171 do_cleanups (old_cleanups);
2176 mi_load_progress (const char *section_name,
2177 unsigned long sent_so_far,
2178 unsigned long total_section,
2179 unsigned long total_sent,
2180 unsigned long grand_total)
2182 struct timeval time_now, delta, update_threshold;
2183 static struct timeval last_update;
2184 static char *previous_sect_name = NULL;
2186 struct ui_out *saved_uiout;
2188 /* This function is called through deprecated_show_load_progress
2189 which means uiout may not be correct. Fix it for the duration
2190 of this function. */
2191 saved_uiout = uiout;
2193 if (current_interp_named_p (INTERP_MI)
2194 || current_interp_named_p (INTERP_MI2))
2195 uiout = mi_out_new (2);
2196 else if (current_interp_named_p (INTERP_MI1))
2197 uiout = mi_out_new (1);
2198 else if (current_interp_named_p (INTERP_MI3))
2199 uiout = mi_out_new (3);
2203 update_threshold.tv_sec = 0;
2204 update_threshold.tv_usec = 500000;
2205 gettimeofday (&time_now, NULL);
2207 delta.tv_usec = time_now.tv_usec - last_update.tv_usec;
2208 delta.tv_sec = time_now.tv_sec - last_update.tv_sec;
2210 if (delta.tv_usec < 0)
2213 delta.tv_usec += 1000000L;
2216 new_section = (previous_sect_name ?
2217 strcmp (previous_sect_name, section_name) : 1);
2220 struct cleanup *cleanup_tuple;
2222 xfree (previous_sect_name);
2223 previous_sect_name = xstrdup (section_name);
2226 fputs_unfiltered (current_token, raw_stdout);
2227 fputs_unfiltered ("+download", raw_stdout);
2228 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
2229 ui_out_field_string (uiout, "section", section_name);
2230 ui_out_field_int (uiout, "section-size", total_section);
2231 ui_out_field_int (uiout, "total-size", grand_total);
2232 do_cleanups (cleanup_tuple);
2233 mi_out_put (uiout, raw_stdout);
2234 fputs_unfiltered ("\n", raw_stdout);
2235 gdb_flush (raw_stdout);
2238 if (delta.tv_sec >= update_threshold.tv_sec &&
2239 delta.tv_usec >= update_threshold.tv_usec)
2241 struct cleanup *cleanup_tuple;
2243 last_update.tv_sec = time_now.tv_sec;
2244 last_update.tv_usec = time_now.tv_usec;
2246 fputs_unfiltered (current_token, raw_stdout);
2247 fputs_unfiltered ("+download", raw_stdout);
2248 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
2249 ui_out_field_string (uiout, "section", section_name);
2250 ui_out_field_int (uiout, "section-sent", sent_so_far);
2251 ui_out_field_int (uiout, "section-size", total_section);
2252 ui_out_field_int (uiout, "total-sent", total_sent);
2253 ui_out_field_int (uiout, "total-size", grand_total);
2254 do_cleanups (cleanup_tuple);
2255 mi_out_put (uiout, raw_stdout);
2256 fputs_unfiltered ("\n", raw_stdout);
2257 gdb_flush (raw_stdout);
2261 uiout = saved_uiout;
2265 timestamp (struct mi_timestamp *tv)
2267 gettimeofday (&tv->wallclock, NULL);
2268 #ifdef HAVE_GETRUSAGE
2269 getrusage (RUSAGE_SELF, &rusage);
2270 tv->utime.tv_sec = rusage.ru_utime.tv_sec;
2271 tv->utime.tv_usec = rusage.ru_utime.tv_usec;
2272 tv->stime.tv_sec = rusage.ru_stime.tv_sec;
2273 tv->stime.tv_usec = rusage.ru_stime.tv_usec;
2276 long usec = get_run_time ();
2278 tv->utime.tv_sec = usec/1000000L;
2279 tv->utime.tv_usec = usec - 1000000L*tv->utime.tv_sec;
2280 tv->stime.tv_sec = 0;
2281 tv->stime.tv_usec = 0;
2287 print_diff_now (struct mi_timestamp *start)
2289 struct mi_timestamp now;
2292 print_diff (start, &now);
2296 mi_print_timing_maybe (void)
2298 /* If the command is -enable-timing then do_timings may be
2299 true whilst current_command_ts is not initialized. */
2300 if (do_timings && current_command_ts)
2301 print_diff_now (current_command_ts);
2305 timeval_diff (struct timeval start, struct timeval end)
2307 return ((end.tv_sec - start.tv_sec) * 1000000L)
2308 + (end.tv_usec - start.tv_usec);
2312 print_diff (struct mi_timestamp *start, struct mi_timestamp *end)
2316 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
2317 timeval_diff (start->wallclock, end->wallclock) / 1000000.0,
2318 timeval_diff (start->utime, end->utime) / 1000000.0,
2319 timeval_diff (start->stime, end->stime) / 1000000.0);
2323 mi_cmd_trace_define_variable (char *command, char **argv, int argc)
2325 struct expression *expr;
2326 struct cleanup *back_to;
2327 LONGEST initval = 0;
2328 struct trace_state_variable *tsv;
2331 if (argc != 1 && argc != 2)
2332 error (_("Usage: -trace-define-variable VARIABLE [VALUE]"));
2334 expr = parse_expression (argv[0]);
2335 back_to = make_cleanup (xfree, expr);
2337 if (expr->nelts == 3 && expr->elts[0].opcode == OP_INTERNALVAR)
2339 struct internalvar *intvar = expr->elts[1].internalvar;
2342 name = internalvar_name (intvar);
2345 if (!name || *name == '\0')
2346 error (_("Invalid name of trace variable"));
2348 tsv = find_trace_state_variable (name);
2350 tsv = create_trace_state_variable (name);
2353 initval = value_as_long (parse_and_eval (argv[1]));
2355 tsv->initial_value = initval;
2357 do_cleanups (back_to);
2361 mi_cmd_trace_list_variables (char *command, char **argv, int argc)
2364 error (_("-trace-list-variables: no arguments are allowed"));
2366 tvariables_info_1 ();
2370 mi_cmd_trace_find (char *command, char **argv, int argc)
2375 error (_("trace selection mode is required"));
2379 if (strcmp (mode, "none") == 0)
2381 tfind_1 (tfind_number, -1, 0, 0, 0);
2385 if (current_trace_status ()->running)
2386 error (_("May not look at trace frames while trace is running."));
2388 if (strcmp (mode, "frame-number") == 0)
2391 error (_("frame number is required"));
2392 tfind_1 (tfind_number, atoi (argv[1]), 0, 0, 0);
2394 else if (strcmp (mode, "tracepoint-number") == 0)
2397 error (_("tracepoint number is required"));
2398 tfind_1 (tfind_tp, atoi (argv[1]), 0, 0, 0);
2400 else if (strcmp (mode, "pc") == 0)
2403 error (_("PC is required"));
2404 tfind_1 (tfind_pc, 0, parse_and_eval_address (argv[1]), 0, 0);
2406 else if (strcmp (mode, "pc-inside-range") == 0)
2409 error (_("Start and end PC are required"));
2410 tfind_1 (tfind_range, 0, parse_and_eval_address (argv[1]),
2411 parse_and_eval_address (argv[2]), 0);
2413 else if (strcmp (mode, "pc-outside-range") == 0)
2416 error (_("Start and end PC are required"));
2417 tfind_1 (tfind_outside, 0, parse_and_eval_address (argv[1]),
2418 parse_and_eval_address (argv[2]), 0);
2420 else if (strcmp (mode, "line") == 0)
2422 struct symtabs_and_lines sals;
2423 struct symtab_and_line sal;
2424 static CORE_ADDR start_pc, end_pc;
2425 struct cleanup *back_to;
2428 error (_("Line is required"));
2430 sals = decode_line_spec (argv[1], 1);
2431 back_to = make_cleanup (xfree, sals.sals);
2435 if (sal.symtab == 0)
2436 error (_("Could not find the specified line"));
2438 if (sal.line > 0 && find_line_pc_range (sal, &start_pc, &end_pc))
2439 tfind_1 (tfind_range, 0, start_pc, end_pc - 1, 0);
2441 error (_("Could not find the specified line"));
2443 do_cleanups (back_to);
2446 error (_("Invalid mode '%s'"), mode);
2448 if (has_stack_frames () || get_traceframe_number () >= 0)
2450 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
2455 mi_cmd_trace_save (char *command, char **argv, int argc)
2457 int target_saves = 0;
2460 if (argc != 1 && argc != 2)
2461 error (_("Usage: -trace-save [-r] filename"));
2466 if (strcmp (argv[0], "-r") == 0)
2469 error (_("Invalid option: %s"), argv[0]);
2476 trace_save (filename, target_saves);
2481 mi_cmd_trace_start (char *command, char **argv, int argc)
2487 mi_cmd_trace_status (char *command, char **argv, int argc)
2489 trace_status_mi (0);
2493 mi_cmd_trace_stop (char *command, char **argv, int argc)
2496 trace_status_mi (1);