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)
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 != 0)
569 ui_out_field_int (uiout, "pid", inferior->pid);
571 if (inferior->pspace->ebfd)
573 ui_out_field_string (uiout, "executable",
574 bfd_get_filename (inferior->pspace->ebfd));
578 if (inferior->pid != 0)
580 data.pid = inferior->pid;
581 iterate_over_threads (collect_cores, &data);
584 if (!VEC_empty (int, data.cores))
587 struct cleanup *back_to_2 =
588 make_cleanup_ui_out_list_begin_end (uiout, "cores");
590 qsort (VEC_address (int, data.cores),
591 VEC_length (int, data.cores), sizeof (int),
592 compare_positive_ints);
594 b = VEC_address (int, data.cores);
595 e = b + VEC_length (int, data.cores);
599 ui_out_field_int (uiout, NULL, *b);
601 do_cleanups (back_to_2);
604 if (top_data->recurse)
605 print_thread_info (uiout, NULL, inferior->pid);
607 do_cleanups (back_to);
613 /* Output a field named 'cores' with a list as the value. The 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"));
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 != 0)
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, struct mi_parse *context)
1821 struct cleanup *cleanup;
1824 current_command_ts = context->cmd_start;
1826 current_token = xstrdup (context->token);
1827 cleanup = make_cleanup (free_current_contents, ¤t_token);
1829 running_result_record_printed = 0;
1831 switch (context->op)
1834 /* A MI command was read from the input stream. */
1836 /* FIXME: gdb_???? */
1837 fprintf_unfiltered (raw_stdout, " token=`%s' command=`%s' args=`%s'\n",
1838 context->token, context->command, context->args);
1841 mi_cmd_execute (context);
1843 /* Print the result if there were no errors.
1845 Remember that on the way out of executing a command, you have
1846 to directly use the mi_interp's uiout, since the command could
1847 have reset the interpreter, in which case the current uiout
1848 will most likely crash in the mi_out_* routines. */
1849 if (!running_result_record_printed)
1851 fputs_unfiltered (context->token, raw_stdout);
1852 /* There's no particularly good reason why target-connect results
1853 in not ^done. Should kill ^connected for MI3. */
1854 fputs_unfiltered (strcmp (context->command, "target-select") == 0
1855 ? "^connected" : "^done", raw_stdout);
1856 mi_out_put (uiout, raw_stdout);
1857 mi_out_rewind (uiout);
1858 mi_print_timing_maybe ();
1859 fputs_unfiltered ("\n", raw_stdout);
1862 /* The command does not want anything to be printed. In that
1863 case, the command probably should not have written anything
1864 to uiout, but in case it has written something, discard it. */
1865 mi_out_rewind (uiout);
1872 /* A CLI command was read from the input stream. */
1873 /* This "feature" will be removed as soon as we have a
1874 complete set of mi commands. */
1875 /* Echo the command on the console. */
1876 fprintf_unfiltered (gdb_stdlog, "%s\n", context->command);
1877 /* Call the "console" interpreter. */
1878 argv[0] = "console";
1879 argv[1] = context->command;
1880 mi_cmd_interpreter_exec ("-interpreter-exec", argv, 2);
1882 /* If we changed interpreters, DON'T print out anything. */
1883 if (current_interp_named_p (INTERP_MI)
1884 || current_interp_named_p (INTERP_MI1)
1885 || current_interp_named_p (INTERP_MI2)
1886 || current_interp_named_p (INTERP_MI3))
1888 if (!running_result_record_printed)
1890 fputs_unfiltered (context->token, raw_stdout);
1891 fputs_unfiltered ("^done", raw_stdout);
1892 mi_out_put (uiout, raw_stdout);
1893 mi_out_rewind (uiout);
1894 mi_print_timing_maybe ();
1895 fputs_unfiltered ("\n", raw_stdout);
1898 mi_out_rewind (uiout);
1905 do_cleanups (cleanup);
1910 /* Print a gdb exception to the MI output stream. */
1913 mi_print_exception (const char *token, struct gdb_exception exception)
1915 fputs_unfiltered (token, raw_stdout);
1916 fputs_unfiltered ("^error,msg=\"", raw_stdout);
1917 if (exception.message == NULL)
1918 fputs_unfiltered ("unknown error", raw_stdout);
1920 fputstr_unfiltered (exception.message, '"', raw_stdout);
1921 fputs_unfiltered ("\"\n", raw_stdout);
1925 mi_execute_command (char *cmd, int from_tty)
1928 struct mi_parse *command = NULL;
1929 volatile struct gdb_exception exception;
1931 /* This is to handle EOF (^D). We just quit gdb. */
1932 /* FIXME: we should call some API function here. */
1934 quit_force (NULL, from_tty);
1936 target_log_command (cmd);
1938 TRY_CATCH (exception, RETURN_MASK_ALL)
1940 command = mi_parse (cmd, &token);
1942 if (exception.reason < 0)
1944 mi_print_exception (token, exception);
1949 volatile struct gdb_exception result;
1950 ptid_t previous_ptid = inferior_ptid;
1952 command->token = token;
1956 command->cmd_start = (struct mi_timestamp *)
1957 xmalloc (sizeof (struct mi_timestamp));
1958 timestamp (command->cmd_start);
1961 TRY_CATCH (result, RETURN_MASK_ALL)
1963 captured_mi_execute_command (uiout, command);
1965 if (result.reason < 0)
1967 /* The command execution failed and error() was called
1969 mi_print_exception (command->token, result);
1970 mi_out_rewind (uiout);
1973 bpstat_do_actions ();
1975 if (/* The notifications are only output when the top-level
1976 interpreter (specified on the command line) is MI. */
1977 ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ()))
1978 /* Don't try report anything if there are no threads --
1979 the program is dead. */
1980 && thread_count () != 0
1981 /* -thread-select explicitly changes thread. If frontend uses that
1982 internally, we don't want to emit =thread-selected, since
1983 =thread-selected is supposed to indicate user's intentions. */
1984 && strcmp (command->command, "thread-select") != 0)
1986 struct mi_interp *mi = top_level_interpreter_data ();
1987 int report_change = 0;
1989 if (command->thread == -1)
1991 report_change = (!ptid_equal (previous_ptid, null_ptid)
1992 && !ptid_equal (inferior_ptid, previous_ptid)
1993 && !ptid_equal (inferior_ptid, null_ptid));
1995 else if (!ptid_equal (inferior_ptid, null_ptid))
1997 struct thread_info *ti = inferior_thread ();
1999 report_change = (ti->num != command->thread);
2004 struct thread_info *ti = inferior_thread ();
2006 target_terminal_ours ();
2007 fprintf_unfiltered (mi->event_channel,
2008 "thread-selected,id=\"%d\"",
2010 gdb_flush (mi->event_channel);
2014 mi_parse_free (command);
2017 fputs_unfiltered ("(gdb) \n", raw_stdout);
2018 gdb_flush (raw_stdout);
2019 /* Print any buffered hook code. */
2024 mi_cmd_execute (struct mi_parse *parse)
2026 struct cleanup *cleanup;
2028 prepare_execute_command ();
2030 cleanup = make_cleanup (null_cleanup, NULL);
2032 if (parse->all && parse->thread_group != -1)
2033 error (_("Cannot specify --thread-group together with --all"));
2035 if (parse->all && parse->thread != -1)
2036 error (_("Cannot specify --thread together with --all"));
2038 if (parse->thread_group != -1 && parse->thread != -1)
2039 error (_("Cannot specify --thread together with --thread-group"));
2041 if (parse->frame != -1 && parse->thread == -1)
2042 error (_("Cannot specify --frame without --thread"));
2044 if (parse->thread_group != -1)
2046 struct inferior *inf = find_inferior_id (parse->thread_group);
2047 struct thread_info *tp = 0;
2050 error (_("Invalid thread group for the --thread-group option"));
2052 set_current_inferior (inf);
2053 /* This behaviour means that if --thread-group option identifies
2054 an inferior with multiple threads, then a random one will be picked.
2055 This is not a problem -- frontend should always provide --thread if
2056 it wishes to operate on a specific thread. */
2058 tp = any_thread_of_process (inf->pid);
2059 switch_to_thread (tp ? tp->ptid : null_ptid);
2060 set_current_program_space (inf->pspace);
2063 if (parse->thread != -1)
2065 struct thread_info *tp = find_thread_id (parse->thread);
2068 error (_("Invalid thread id: %d"), parse->thread);
2070 if (is_exited (tp->ptid))
2071 error (_("Thread id: %d has terminated"), parse->thread);
2073 switch_to_thread (tp->ptid);
2076 if (parse->frame != -1)
2078 struct frame_info *fid;
2079 int frame = parse->frame;
2081 fid = find_relative_frame (get_current_frame (), &frame);
2083 /* find_relative_frame was successful */
2086 error (_("Invalid frame id: %d"), frame);
2089 current_context = parse;
2091 if (parse->cmd->argv_func != NULL)
2092 parse->cmd->argv_func (parse->command, parse->argv, parse->argc);
2093 else if (parse->cmd->cli.cmd != 0)
2095 /* FIXME: DELETE THIS. */
2096 /* The operation is still implemented by a cli command. */
2097 /* Must be a synchronous one. */
2098 mi_execute_cli_command (parse->cmd->cli.cmd, parse->cmd->cli.args_p,
2103 /* FIXME: DELETE THIS. */
2104 struct ui_file *stb;
2106 stb = mem_fileopen ();
2108 fputs_unfiltered ("Undefined mi command: ", stb);
2109 fputstr_unfiltered (parse->command, '"', stb);
2110 fputs_unfiltered (" (missing implementation)", stb);
2112 make_cleanup_ui_file_delete (stb);
2115 do_cleanups (cleanup);
2118 /* FIXME: This is just a hack so we can get some extra commands going.
2119 We don't want to channel things through the CLI, but call libgdb directly.
2120 Use only for synchronous commands. */
2123 mi_execute_cli_command (const char *cmd, int args_p, const char *args)
2127 struct cleanup *old_cleanups;
2131 run = xstrprintf ("%s %s", cmd, args);
2133 run = xstrdup (cmd);
2135 /* FIXME: gdb_???? */
2136 fprintf_unfiltered (gdb_stdout, "cli=%s run=%s\n",
2138 old_cleanups = make_cleanup (xfree, run);
2139 execute_command ( /*ui */ run, 0 /*from_tty */ );
2140 do_cleanups (old_cleanups);
2146 mi_execute_async_cli_command (char *cli_command, char **argv, int argc)
2148 struct cleanup *old_cleanups;
2151 if (target_can_async_p ())
2152 run = xstrprintf ("%s %s&", cli_command, argc ? *argv : "");
2154 run = xstrprintf ("%s %s", cli_command, argc ? *argv : "");
2155 old_cleanups = make_cleanup (xfree, run);
2157 execute_command ( /*ui */ run, 0 /*from_tty */ );
2159 if (target_can_async_p ())
2161 /* If we're not executing, an exception should have been throw. */
2162 gdb_assert (is_running (inferior_ptid));
2163 do_cleanups (old_cleanups);
2167 /* Do this before doing any printing. It would appear that some
2168 print code leaves garbage around in the buffer. */
2169 do_cleanups (old_cleanups);
2174 mi_load_progress (const char *section_name,
2175 unsigned long sent_so_far,
2176 unsigned long total_section,
2177 unsigned long total_sent,
2178 unsigned long grand_total)
2180 struct timeval time_now, delta, update_threshold;
2181 static struct timeval last_update;
2182 static char *previous_sect_name = NULL;
2184 struct ui_out *saved_uiout;
2186 /* This function is called through deprecated_show_load_progress
2187 which means uiout may not be correct. Fix it for the duration
2188 of this function. */
2189 saved_uiout = uiout;
2191 if (current_interp_named_p (INTERP_MI)
2192 || current_interp_named_p (INTERP_MI2))
2193 uiout = mi_out_new (2);
2194 else if (current_interp_named_p (INTERP_MI1))
2195 uiout = mi_out_new (1);
2196 else if (current_interp_named_p (INTERP_MI3))
2197 uiout = mi_out_new (3);
2201 update_threshold.tv_sec = 0;
2202 update_threshold.tv_usec = 500000;
2203 gettimeofday (&time_now, NULL);
2205 delta.tv_usec = time_now.tv_usec - last_update.tv_usec;
2206 delta.tv_sec = time_now.tv_sec - last_update.tv_sec;
2208 if (delta.tv_usec < 0)
2211 delta.tv_usec += 1000000L;
2214 new_section = (previous_sect_name ?
2215 strcmp (previous_sect_name, section_name) : 1);
2218 struct cleanup *cleanup_tuple;
2220 xfree (previous_sect_name);
2221 previous_sect_name = xstrdup (section_name);
2224 fputs_unfiltered (current_token, raw_stdout);
2225 fputs_unfiltered ("+download", raw_stdout);
2226 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
2227 ui_out_field_string (uiout, "section", section_name);
2228 ui_out_field_int (uiout, "section-size", total_section);
2229 ui_out_field_int (uiout, "total-size", grand_total);
2230 do_cleanups (cleanup_tuple);
2231 mi_out_put (uiout, raw_stdout);
2232 fputs_unfiltered ("\n", raw_stdout);
2233 gdb_flush (raw_stdout);
2236 if (delta.tv_sec >= update_threshold.tv_sec &&
2237 delta.tv_usec >= update_threshold.tv_usec)
2239 struct cleanup *cleanup_tuple;
2241 last_update.tv_sec = time_now.tv_sec;
2242 last_update.tv_usec = time_now.tv_usec;
2244 fputs_unfiltered (current_token, raw_stdout);
2245 fputs_unfiltered ("+download", raw_stdout);
2246 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
2247 ui_out_field_string (uiout, "section", section_name);
2248 ui_out_field_int (uiout, "section-sent", sent_so_far);
2249 ui_out_field_int (uiout, "section-size", total_section);
2250 ui_out_field_int (uiout, "total-sent", total_sent);
2251 ui_out_field_int (uiout, "total-size", grand_total);
2252 do_cleanups (cleanup_tuple);
2253 mi_out_put (uiout, raw_stdout);
2254 fputs_unfiltered ("\n", raw_stdout);
2255 gdb_flush (raw_stdout);
2259 uiout = saved_uiout;
2263 timestamp (struct mi_timestamp *tv)
2265 gettimeofday (&tv->wallclock, NULL);
2266 #ifdef HAVE_GETRUSAGE
2267 getrusage (RUSAGE_SELF, &rusage);
2268 tv->utime.tv_sec = rusage.ru_utime.tv_sec;
2269 tv->utime.tv_usec = rusage.ru_utime.tv_usec;
2270 tv->stime.tv_sec = rusage.ru_stime.tv_sec;
2271 tv->stime.tv_usec = rusage.ru_stime.tv_usec;
2274 long usec = get_run_time ();
2276 tv->utime.tv_sec = usec/1000000L;
2277 tv->utime.tv_usec = usec - 1000000L*tv->utime.tv_sec;
2278 tv->stime.tv_sec = 0;
2279 tv->stime.tv_usec = 0;
2285 print_diff_now (struct mi_timestamp *start)
2287 struct mi_timestamp now;
2290 print_diff (start, &now);
2294 mi_print_timing_maybe (void)
2296 /* If the command is -enable-timing then do_timings may be
2297 true whilst current_command_ts is not initialized. */
2298 if (do_timings && current_command_ts)
2299 print_diff_now (current_command_ts);
2303 timeval_diff (struct timeval start, struct timeval end)
2305 return ((end.tv_sec - start.tv_sec) * 1000000L)
2306 + (end.tv_usec - start.tv_usec);
2310 print_diff (struct mi_timestamp *start, struct mi_timestamp *end)
2314 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
2315 timeval_diff (start->wallclock, end->wallclock) / 1000000.0,
2316 timeval_diff (start->utime, end->utime) / 1000000.0,
2317 timeval_diff (start->stime, end->stime) / 1000000.0);
2321 mi_cmd_trace_define_variable (char *command, char **argv, int argc)
2323 struct expression *expr;
2324 struct cleanup *back_to;
2325 LONGEST initval = 0;
2326 struct trace_state_variable *tsv;
2329 if (argc != 1 && argc != 2)
2330 error (_("Usage: -trace-define-variable VARIABLE [VALUE]"));
2332 expr = parse_expression (argv[0]);
2333 back_to = make_cleanup (xfree, expr);
2335 if (expr->nelts == 3 && expr->elts[0].opcode == OP_INTERNALVAR)
2337 struct internalvar *intvar = expr->elts[1].internalvar;
2340 name = internalvar_name (intvar);
2343 if (!name || *name == '\0')
2344 error (_("Invalid name of trace variable"));
2346 tsv = find_trace_state_variable (name);
2348 tsv = create_trace_state_variable (name);
2351 initval = value_as_long (parse_and_eval (argv[1]));
2353 tsv->initial_value = initval;
2355 do_cleanups (back_to);
2359 mi_cmd_trace_list_variables (char *command, char **argv, int argc)
2362 error (_("-trace-list-variables: no arguments are allowed"));
2364 tvariables_info_1 ();
2368 mi_cmd_trace_find (char *command, char **argv, int argc)
2373 error (_("trace selection mode is required"));
2377 if (strcmp (mode, "none") == 0)
2379 tfind_1 (tfind_number, -1, 0, 0, 0);
2383 if (current_trace_status ()->running)
2384 error (_("May not look at trace frames while trace is running."));
2386 if (strcmp (mode, "frame-number") == 0)
2389 error (_("frame number is required"));
2390 tfind_1 (tfind_number, atoi (argv[1]), 0, 0, 0);
2392 else if (strcmp (mode, "tracepoint-number") == 0)
2395 error (_("tracepoint number is required"));
2396 tfind_1 (tfind_tp, atoi (argv[1]), 0, 0, 0);
2398 else if (strcmp (mode, "pc") == 0)
2401 error (_("PC is required"));
2402 tfind_1 (tfind_pc, 0, parse_and_eval_address (argv[1]), 0, 0);
2404 else if (strcmp (mode, "pc-inside-range") == 0)
2407 error (_("Start and end PC are required"));
2408 tfind_1 (tfind_range, 0, parse_and_eval_address (argv[1]),
2409 parse_and_eval_address (argv[2]), 0);
2411 else if (strcmp (mode, "pc-outside-range") == 0)
2414 error (_("Start and end PC are required"));
2415 tfind_1 (tfind_outside, 0, parse_and_eval_address (argv[1]),
2416 parse_and_eval_address (argv[2]), 0);
2418 else if (strcmp (mode, "line") == 0)
2420 struct symtabs_and_lines sals;
2421 struct symtab_and_line sal;
2422 static CORE_ADDR start_pc, end_pc;
2423 struct cleanup *back_to;
2426 error (_("Line is required"));
2428 sals = decode_line_spec (argv[1], 1);
2429 back_to = make_cleanup (xfree, sals.sals);
2433 if (sal.symtab == 0)
2434 error (_("Could not find the specified line"));
2436 if (sal.line > 0 && find_line_pc_range (sal, &start_pc, &end_pc))
2437 tfind_1 (tfind_range, 0, start_pc, end_pc - 1, 0);
2439 error (_("Could not find the specified line"));
2441 do_cleanups (back_to);
2444 error (_("Invalid mode '%s'"), mode);
2446 if (has_stack_frames () || get_traceframe_number () >= 0)
2448 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
2453 mi_cmd_trace_save (char *command, char **argv, int argc)
2455 int target_saves = 0;
2458 if (argc != 1 && argc != 2)
2459 error (_("Usage: -trace-save [-r] filename"));
2464 if (strcmp (argv[0], "-r") == 0)
2467 error (_("Invalid option: %s"), argv[0]);
2474 trace_save (filename, target_saves);
2479 mi_cmd_trace_start (char *command, char **argv, int argc)
2485 mi_cmd_trace_status (char *command, char **argv, int argc)
2487 trace_status_mi (0);
2491 mi_cmd_trace_stop (char *command, char **argv, int argc)
2494 trace_status_mi (1);