3 Copyright (C) 2000-2013 Free Software Foundation, Inc.
5 Contributed by Cygnus Solutions (a Red Hat company).
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "arch-utils.h"
26 #include "gdb_string.h"
27 #include "exceptions.h"
29 #include "gdbthread.h"
32 #include "mi-getopt.h"
33 #include "mi-console.h"
37 #include "event-loop.h"
38 #include "event-top.h"
39 #include "gdbcore.h" /* For write_memory(). */
45 #include "mi-common.h"
50 #include "splay-tree.h"
51 #include "tracepoint.h"
56 #include "python/python-internal.h"
62 #if defined HAVE_SYS_RESOURCE_H
63 #include <sys/resource.h>
77 struct ui_file *raw_stdout;
79 /* This is used to pass the current command timestamp down to
80 continuation routines. */
81 static struct mi_timestamp *current_command_ts;
83 static int do_timings = 0;
86 /* Few commands would like to know if options like --thread-group were
87 explicitly specified. This variable keeps the current parsed
88 command including all option, and make it possible. */
89 static struct mi_parse *current_context;
91 int running_result_record_printed = 1;
93 /* Flag indicating that the target has proceeded since the last
94 command was issued. */
97 extern void _initialize_mi_main (void);
98 static void mi_cmd_execute (struct mi_parse *parse);
100 static void mi_execute_cli_command (const char *cmd, int args_p,
102 static void mi_execute_async_cli_command (char *cli_command,
103 char **argv, int argc);
104 static int register_changed_p (int regnum, struct regcache *,
106 static void output_register (struct frame_info *, int regnum, int format);
108 /* Command implementations. FIXME: Is this libgdb? No. This is the MI
109 layer that calls libgdb. Any operation used in the below should be
112 static void timestamp (struct mi_timestamp *tv);
114 static void print_diff_now (struct mi_timestamp *start);
115 static void print_diff (struct mi_timestamp *start, struct mi_timestamp *end);
118 mi_cmd_gdb_exit (char *command, char **argv, int argc)
120 /* We have to print everything right here because we never return. */
122 fputs_unfiltered (current_token, raw_stdout);
123 fputs_unfiltered ("^exit\n", raw_stdout);
124 mi_out_put (current_uiout, raw_stdout);
125 gdb_flush (raw_stdout);
126 /* FIXME: The function called is not yet a formal libgdb function. */
127 quit_force (NULL, FROM_TTY);
131 mi_cmd_exec_next (char *command, char **argv, int argc)
133 /* FIXME: Should call a libgdb function, not a cli wrapper. */
134 if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
135 mi_execute_async_cli_command ("reverse-next", argv + 1, argc - 1);
137 mi_execute_async_cli_command ("next", argv, argc);
141 mi_cmd_exec_next_instruction (char *command, char **argv, int argc)
143 /* FIXME: Should call a libgdb function, not a cli wrapper. */
144 if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
145 mi_execute_async_cli_command ("reverse-nexti", argv + 1, argc - 1);
147 mi_execute_async_cli_command ("nexti", argv, argc);
151 mi_cmd_exec_step (char *command, char **argv, int argc)
153 /* FIXME: Should call a libgdb function, not a cli wrapper. */
154 if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
155 mi_execute_async_cli_command ("reverse-step", argv + 1, argc - 1);
157 mi_execute_async_cli_command ("step", argv, argc);
161 mi_cmd_exec_step_instruction (char *command, char **argv, int argc)
163 /* FIXME: Should call a libgdb function, not a cli wrapper. */
164 if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
165 mi_execute_async_cli_command ("reverse-stepi", argv + 1, argc - 1);
167 mi_execute_async_cli_command ("stepi", argv, argc);
171 mi_cmd_exec_finish (char *command, char **argv, int argc)
173 /* FIXME: Should call a libgdb function, not a cli wrapper. */
174 if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
175 mi_execute_async_cli_command ("reverse-finish", argv + 1, argc - 1);
177 mi_execute_async_cli_command ("finish", argv, argc);
181 mi_cmd_exec_return (char *command, char **argv, int argc)
183 /* This command doesn't really execute the target, it just pops the
184 specified number of frames. */
186 /* Call return_command with from_tty argument equal to 0 so as to
187 avoid being queried. */
188 return_command (*argv, 0);
190 /* Call return_command with from_tty argument equal to 0 so as to
191 avoid being queried. */
192 return_command (NULL, 0);
194 /* Because we have called return_command with from_tty = 0, we need
195 to print the frame here. */
196 print_stack_frame (get_selected_frame (NULL), 1, LOC_AND_ADDRESS);
200 mi_cmd_exec_jump (char *args, char **argv, int argc)
202 /* FIXME: Should call a libgdb function, not a cli wrapper. */
203 mi_execute_async_cli_command ("jump", argv, argc);
207 proceed_thread (struct thread_info *thread, int pid)
209 if (!is_stopped (thread->ptid))
212 if (pid != 0 && PIDGET (thread->ptid) != pid)
215 switch_to_thread (thread->ptid);
216 clear_proceed_status ();
217 proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT, 0);
221 proceed_thread_callback (struct thread_info *thread, void *arg)
223 int pid = *(int *)arg;
225 proceed_thread (thread, pid);
230 exec_continue (char **argv, int argc)
234 /* In non-stop mode, 'resume' always resumes a single thread.
235 Therefore, to resume all threads of the current inferior, or
236 all threads in all inferiors, we need to iterate over
239 See comment on infcmd.c:proceed_thread_callback for rationale. */
240 if (current_context->all || current_context->thread_group != -1)
243 struct cleanup *back_to = make_cleanup_restore_current_thread ();
245 if (!current_context->all)
248 = find_inferior_id (current_context->thread_group);
252 iterate_over_threads (proceed_thread_callback, &pid);
253 do_cleanups (back_to);
262 struct cleanup *back_to = make_cleanup_restore_integer (&sched_multi);
264 if (current_context->all)
271 /* In all-stop mode, -exec-continue traditionally resumed
272 either all threads, or one thread, depending on the
273 'scheduler-locking' variable. Let's continue to do the
277 do_cleanups (back_to);
282 exec_direction_forward (void *notused)
284 execution_direction = EXEC_FORWARD;
288 exec_reverse_continue (char **argv, int argc)
290 enum exec_direction_kind dir = execution_direction;
291 struct cleanup *old_chain;
293 if (dir == EXEC_REVERSE)
294 error (_("Already in reverse mode."));
296 if (!target_can_execute_reverse)
297 error (_("Target %s does not support this command."), target_shortname);
299 old_chain = make_cleanup (exec_direction_forward, NULL);
300 execution_direction = EXEC_REVERSE;
301 exec_continue (argv, argc);
302 do_cleanups (old_chain);
306 mi_cmd_exec_continue (char *command, char **argv, int argc)
308 if (argc > 0 && strcmp (argv[0], "--reverse") == 0)
309 exec_reverse_continue (argv + 1, argc - 1);
311 exec_continue (argv, argc);
315 interrupt_thread_callback (struct thread_info *thread, void *arg)
317 int pid = *(int *)arg;
319 if (!is_running (thread->ptid))
322 if (PIDGET (thread->ptid) != pid)
325 target_stop (thread->ptid);
329 /* Interrupt the execution of the target. Note how we must play
330 around with the token variables, in order to display the current
331 token in the result of the interrupt command, and the previous
332 execution token when the target finally stops. See comments in
336 mi_cmd_exec_interrupt (char *command, char **argv, int argc)
338 /* In all-stop mode, everything stops, so we don't need to try
339 anything specific. */
342 interrupt_target_1 (0);
346 if (current_context->all)
348 /* This will interrupt all threads in all inferiors. */
349 interrupt_target_1 (1);
351 else if (current_context->thread_group != -1)
353 struct inferior *inf = find_inferior_id (current_context->thread_group);
355 iterate_over_threads (interrupt_thread_callback, &inf->pid);
359 /* Interrupt just the current thread -- either explicitly
360 specified via --thread or whatever was current before
361 MI command was sent. */
362 interrupt_target_1 (0);
367 run_one_inferior (struct inferior *inf, void *arg)
371 if (inf->pid != ptid_get_pid (inferior_ptid))
373 struct thread_info *tp;
375 tp = any_thread_of_process (inf->pid);
377 error (_("Inferior has no threads."));
379 switch_to_thread (tp->ptid);
384 set_current_inferior (inf);
385 switch_to_thread (null_ptid);
386 set_current_program_space (inf->pspace);
388 mi_execute_cli_command ("run", target_can_async_p (),
389 target_can_async_p () ? "&" : NULL);
394 mi_cmd_exec_run (char *command, char **argv, int argc)
396 if (current_context->all)
398 struct cleanup *back_to = save_current_space_and_thread ();
400 iterate_over_inferiors (run_one_inferior, NULL);
401 do_cleanups (back_to);
405 mi_execute_cli_command ("run", target_can_async_p (),
406 target_can_async_p () ? "&" : NULL);
412 find_thread_of_process (struct thread_info *ti, void *p)
416 if (PIDGET (ti->ptid) == pid && !is_exited (ti->ptid))
423 mi_cmd_target_detach (char *command, char **argv, int argc)
425 if (argc != 0 && argc != 1)
426 error (_("Usage: -target-detach [pid | thread-group]"));
430 struct thread_info *tp;
434 /* First see if we are dealing with a thread-group id. */
437 struct inferior *inf;
438 int id = strtoul (argv[0] + 1, &end, 0);
441 error (_("Invalid syntax of thread-group id '%s'"), argv[0]);
443 inf = find_inferior_id (id);
445 error (_("Non-existent thread-group id '%d'"), id);
451 /* We must be dealing with a pid. */
452 pid = strtol (argv[0], &end, 10);
455 error (_("Invalid identifier '%s'"), argv[0]);
458 /* Pick any thread in the desired process. Current
459 target_detach detaches from the parent of inferior_ptid. */
460 tp = iterate_over_threads (find_thread_of_process, &pid);
462 error (_("Thread group is empty"));
464 switch_to_thread (tp->ptid);
467 detach_command (NULL, 0);
471 mi_cmd_thread_select (char *command, char **argv, int argc)
474 char *mi_error_message;
477 error (_("-thread-select: USAGE: threadnum."));
479 rc = gdb_thread_select (current_uiout, argv[0], &mi_error_message);
481 if (rc == GDB_RC_FAIL)
483 make_cleanup (xfree, mi_error_message);
484 error ("%s", mi_error_message);
489 mi_cmd_thread_list_ids (char *command, char **argv, int argc)
492 char *mi_error_message;
495 error (_("-thread-list-ids: No arguments required."));
497 rc = gdb_list_thread_ids (current_uiout, &mi_error_message);
499 if (rc == GDB_RC_FAIL)
501 make_cleanup (xfree, mi_error_message);
502 error ("%s", mi_error_message);
507 mi_cmd_thread_info (char *command, char **argv, int argc)
509 if (argc != 0 && argc != 1)
510 error (_("Invalid MI command"));
512 print_thread_info (current_uiout, argv[0], -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;
561 struct ui_out *uiout = current_uiout;
563 if (VEC_empty (int, top_data->inferiors)
564 || bsearch (&(inferior->pid), VEC_address (int, top_data->inferiors),
565 VEC_length (int, top_data->inferiors), sizeof (int),
566 compare_positive_ints))
568 struct collect_cores_data data;
569 struct cleanup *back_to
570 = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
572 ui_out_field_fmt (uiout, "id", "i%d", inferior->num);
573 ui_out_field_string (uiout, "type", "process");
574 if (inferior->pid != 0)
575 ui_out_field_int (uiout, "pid", inferior->pid);
577 if (inferior->pspace->ebfd)
579 ui_out_field_string (uiout, "executable",
580 bfd_get_filename (inferior->pspace->ebfd));
584 if (inferior->pid != 0)
586 data.pid = inferior->pid;
587 iterate_over_threads (collect_cores, &data);
590 if (!VEC_empty (int, data.cores))
593 struct cleanup *back_to_2 =
594 make_cleanup_ui_out_list_begin_end (uiout, "cores");
596 qsort (VEC_address (int, data.cores),
597 VEC_length (int, data.cores), sizeof (int),
598 compare_positive_ints);
600 b = VEC_address (int, data.cores);
601 e = b + VEC_length (int, data.cores);
605 ui_out_field_int (uiout, NULL, *b);
607 do_cleanups (back_to_2);
610 if (top_data->recurse)
611 print_thread_info (uiout, NULL, inferior->pid);
613 do_cleanups (back_to);
619 /* Output a field named 'cores' with a list as the value. The
620 elements of the list are obtained by splitting 'cores' on
624 output_cores (struct ui_out *uiout, const char *field_name, const char *xcores)
626 struct cleanup *back_to = make_cleanup_ui_out_list_begin_end (uiout,
628 char *cores = xstrdup (xcores);
631 make_cleanup (xfree, cores);
633 for (p = strtok (p, ","); p; p = strtok (NULL, ","))
634 ui_out_field_string (uiout, NULL, p);
636 do_cleanups (back_to);
640 free_vector_of_ints (void *xvector)
642 VEC (int) **vector = xvector;
644 VEC_free (int, *vector);
648 do_nothing (splay_tree_key k)
653 free_vector_of_osdata_items (splay_tree_value xvalue)
655 VEC (osdata_item_s) *value = (VEC (osdata_item_s) *) xvalue;
657 /* We don't free the items itself, it will be done separately. */
658 VEC_free (osdata_item_s, value);
662 splay_tree_int_comparator (splay_tree_key xa, splay_tree_key xb)
671 free_splay_tree (void *xt)
674 splay_tree_delete (t);
678 list_available_thread_groups (VEC (int) *ids, int recurse)
681 struct osdata_item *item;
683 struct ui_out *uiout = current_uiout;
684 struct cleanup *cleanup;
686 /* This keeps a map from integer (pid) to VEC (struct osdata_item *)*
687 The vector contains information about all threads for the given pid.
688 This is assigned an initial value to avoid "may be used uninitialized"
690 splay_tree tree = NULL;
692 /* get_osdata will throw if it cannot return data. */
693 data = get_osdata ("processes");
694 cleanup = make_cleanup_osdata_free (data);
698 struct osdata *threads = get_osdata ("threads");
700 make_cleanup_osdata_free (threads);
701 tree = splay_tree_new (splay_tree_int_comparator,
703 free_vector_of_osdata_items);
704 make_cleanup (free_splay_tree, tree);
707 VEC_iterate (osdata_item_s, threads->items,
711 const char *pid = get_osdata_column (item, "pid");
712 int pid_i = strtoul (pid, NULL, 0);
713 VEC (osdata_item_s) *vec = 0;
715 splay_tree_node n = splay_tree_lookup (tree, pid_i);
718 VEC_safe_push (osdata_item_s, vec, item);
719 splay_tree_insert (tree, pid_i, (splay_tree_value)vec);
723 vec = (VEC (osdata_item_s) *) n->value;
724 VEC_safe_push (osdata_item_s, vec, item);
725 n->value = (splay_tree_value) vec;
730 make_cleanup_ui_out_list_begin_end (uiout, "groups");
733 VEC_iterate (osdata_item_s, data->items,
737 struct cleanup *back_to;
739 const char *pid = get_osdata_column (item, "pid");
740 const char *cmd = get_osdata_column (item, "command");
741 const char *user = get_osdata_column (item, "user");
742 const char *cores = get_osdata_column (item, "cores");
744 int pid_i = strtoul (pid, NULL, 0);
746 /* At present, the target will return all available processes
747 and if information about specific ones was required, we filter
748 undesired processes here. */
749 if (ids && bsearch (&pid_i, VEC_address (int, ids),
750 VEC_length (int, ids),
751 sizeof (int), compare_positive_ints) == NULL)
755 back_to = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
757 ui_out_field_fmt (uiout, "id", "%s", pid);
758 ui_out_field_string (uiout, "type", "process");
760 ui_out_field_string (uiout, "description", cmd);
762 ui_out_field_string (uiout, "user", user);
764 output_cores (uiout, "cores", cores);
768 splay_tree_node n = splay_tree_lookup (tree, pid_i);
771 VEC (osdata_item_s) *children = (VEC (osdata_item_s) *) n->value;
772 struct osdata_item *child;
775 make_cleanup_ui_out_list_begin_end (uiout, "threads");
778 VEC_iterate (osdata_item_s, children, ix_child, child);
781 struct cleanup *back_to_2 =
782 make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
783 const char *tid = get_osdata_column (child, "tid");
784 const char *tcore = get_osdata_column (child, "core");
786 ui_out_field_string (uiout, "id", tid);
788 ui_out_field_string (uiout, "core", tcore);
790 do_cleanups (back_to_2);
795 do_cleanups (back_to);
798 do_cleanups (cleanup);
802 mi_cmd_list_thread_groups (char *command, char **argv, int argc)
804 struct ui_out *uiout = current_uiout;
805 struct cleanup *back_to;
812 AVAILABLE_OPT, RECURSE_OPT
814 static const struct mi_opt opts[] =
816 {"-available", AVAILABLE_OPT, 0},
817 {"-recurse", RECURSE_OPT, 1},
826 int opt = mi_getopt ("-list-thread-groups", argc, argv, opts,
831 switch ((enum opt) opt)
837 if (strcmp (oarg, "0") == 0)
839 else if (strcmp (oarg, "1") == 0)
842 error (_("only '0' and '1' are valid values "
843 "for the '--recurse' option"));
848 for (; oind < argc; ++oind)
853 if (*(argv[oind]) != 'i')
854 error (_("invalid syntax of group id '%s'"), argv[oind]);
856 inf = strtoul (argv[oind] + 1, &end, 0);
859 error (_("invalid syntax of group id '%s'"), argv[oind]);
860 VEC_safe_push (int, ids, inf);
862 if (VEC_length (int, ids) > 1)
863 qsort (VEC_address (int, ids),
864 VEC_length (int, ids),
865 sizeof (int), compare_positive_ints);
867 back_to = make_cleanup (free_vector_of_ints, &ids);
871 list_available_thread_groups (ids, recurse);
873 else if (VEC_length (int, ids) == 1)
875 /* Local thread groups, single id. */
876 int id = *VEC_address (int, ids);
877 struct inferior *inf = find_inferior_id (id);
880 error (_("Non-existent thread group id '%d'"), id);
882 print_thread_info (uiout, NULL, inf->pid);
886 struct print_one_inferior_data data;
888 data.recurse = recurse;
889 data.inferiors = ids;
891 /* Local thread groups. Either no explicit ids -- and we
892 print everything, or several explicit ids. In both cases,
893 we print more than one group, and have to use 'groups'
894 as the top-level element. */
895 make_cleanup_ui_out_list_begin_end (uiout, "groups");
896 update_thread_list ();
897 iterate_over_inferiors (print_one_inferior, &data);
900 do_cleanups (back_to);
904 mi_cmd_data_list_register_names (char *command, char **argv, int argc)
906 struct gdbarch *gdbarch;
907 struct ui_out *uiout = current_uiout;
910 struct cleanup *cleanup;
912 /* Note that the test for a valid register must include checking the
913 gdbarch_register_name because gdbarch_num_regs may be allocated
914 for the union of the register sets within a family of related
915 processors. In this case, some entries of gdbarch_register_name
916 will change depending upon the particular processor being
919 gdbarch = get_current_arch ();
920 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
922 cleanup = make_cleanup_ui_out_list_begin_end (uiout, "register-names");
924 if (argc == 0) /* No args, just do all the regs. */
930 if (gdbarch_register_name (gdbarch, regnum) == NULL
931 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
932 ui_out_field_string (uiout, NULL, "");
934 ui_out_field_string (uiout, NULL,
935 gdbarch_register_name (gdbarch, regnum));
939 /* Else, list of register #s, just do listed regs. */
940 for (i = 0; i < argc; i++)
942 regnum = atoi (argv[i]);
943 if (regnum < 0 || regnum >= numregs)
944 error (_("bad register number"));
946 if (gdbarch_register_name (gdbarch, regnum) == NULL
947 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
948 ui_out_field_string (uiout, NULL, "");
950 ui_out_field_string (uiout, NULL,
951 gdbarch_register_name (gdbarch, regnum));
953 do_cleanups (cleanup);
957 mi_cmd_data_list_changed_registers (char *command, char **argv, int argc)
959 static struct regcache *this_regs = NULL;
960 struct ui_out *uiout = current_uiout;
961 struct regcache *prev_regs;
962 struct gdbarch *gdbarch;
963 int regnum, numregs, changed;
965 struct cleanup *cleanup;
967 /* The last time we visited this function, the current frame's
968 register contents were saved in THIS_REGS. Move THIS_REGS over
969 to PREV_REGS, and refresh THIS_REGS with the now-current register
972 prev_regs = this_regs;
973 this_regs = frame_save_as_regcache (get_selected_frame (NULL));
974 cleanup = make_cleanup_regcache_xfree (prev_regs);
976 /* Note that the test for a valid register must include checking the
977 gdbarch_register_name because gdbarch_num_regs may be allocated
978 for the union of the register sets within a family of related
979 processors. In this case, some entries of gdbarch_register_name
980 will change depending upon the particular processor being
983 gdbarch = get_regcache_arch (this_regs);
984 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
986 make_cleanup_ui_out_list_begin_end (uiout, "changed-registers");
990 /* No args, just do all the regs. */
995 if (gdbarch_register_name (gdbarch, regnum) == NULL
996 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
998 changed = register_changed_p (regnum, prev_regs, this_regs);
1000 error (_("-data-list-changed-registers: "
1001 "Unable to read register contents."));
1003 ui_out_field_int (uiout, NULL, regnum);
1007 /* Else, list of register #s, just do listed regs. */
1008 for (i = 0; i < argc; i++)
1010 regnum = atoi (argv[i]);
1014 && gdbarch_register_name (gdbarch, regnum) != NULL
1015 && *gdbarch_register_name (gdbarch, regnum) != '\000')
1017 changed = register_changed_p (regnum, prev_regs, this_regs);
1019 error (_("-data-list-changed-registers: "
1020 "Unable to read register contents."));
1022 ui_out_field_int (uiout, NULL, regnum);
1025 error (_("bad register number"));
1027 do_cleanups (cleanup);
1031 register_changed_p (int regnum, struct regcache *prev_regs,
1032 struct regcache *this_regs)
1034 struct gdbarch *gdbarch = get_regcache_arch (this_regs);
1035 gdb_byte prev_buffer[MAX_REGISTER_SIZE];
1036 gdb_byte this_buffer[MAX_REGISTER_SIZE];
1037 enum register_status prev_status;
1038 enum register_status this_status;
1040 /* First time through or after gdbarch change consider all registers
1042 if (!prev_regs || get_regcache_arch (prev_regs) != gdbarch)
1045 /* Get register contents and compare. */
1046 prev_status = regcache_cooked_read (prev_regs, regnum, prev_buffer);
1047 this_status = regcache_cooked_read (this_regs, regnum, this_buffer);
1049 if (this_status != prev_status)
1051 else if (this_status == REG_VALID)
1052 return memcmp (prev_buffer, this_buffer,
1053 register_size (gdbarch, regnum)) != 0;
1058 /* Return a list of register number and value pairs. The valid
1059 arguments expected are: a letter indicating the format in which to
1060 display the registers contents. This can be one of: x
1061 (hexadecimal), d (decimal), N (natural), t (binary), o (octal), r
1062 (raw). After the format argument there can be a sequence of
1063 numbers, indicating which registers to fetch the content of. If
1064 the format is the only argument, a list of all the registers with
1065 their values is returned. */
1068 mi_cmd_data_list_register_values (char *command, char **argv, int argc)
1070 struct ui_out *uiout = current_uiout;
1071 struct frame_info *frame;
1072 struct gdbarch *gdbarch;
1073 int regnum, numregs, format;
1075 struct cleanup *list_cleanup;
1077 /* Note that the test for a valid register must include checking the
1078 gdbarch_register_name because gdbarch_num_regs may be allocated
1079 for the union of the register sets within a family of related
1080 processors. In this case, some entries of gdbarch_register_name
1081 will change depending upon the particular processor being
1085 error (_("-data-list-register-values: Usage: "
1086 "-data-list-register-values <format> [<regnum1>...<regnumN>]"));
1088 format = (int) argv[0][0];
1090 frame = get_selected_frame (NULL);
1091 gdbarch = get_frame_arch (frame);
1092 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
1094 list_cleanup = make_cleanup_ui_out_list_begin_end (uiout, "register-values");
1098 /* No args, beside the format: do all the regs. */
1103 if (gdbarch_register_name (gdbarch, regnum) == NULL
1104 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
1107 output_register (frame, regnum, format);
1111 /* Else, list of register #s, just do listed regs. */
1112 for (i = 1; i < argc; i++)
1114 regnum = atoi (argv[i]);
1118 && gdbarch_register_name (gdbarch, regnum) != NULL
1119 && *gdbarch_register_name (gdbarch, regnum) != '\000')
1120 output_register (frame, regnum, format);
1122 error (_("bad register number"));
1124 do_cleanups (list_cleanup);
1127 /* Output register REGNUM's contents in the desired FORMAT. */
1130 output_register (struct frame_info *frame, int regnum, int format)
1132 struct gdbarch *gdbarch = get_frame_arch (frame);
1133 struct ui_out *uiout = current_uiout;
1135 struct cleanup *tuple_cleanup;
1137 tuple_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1138 ui_out_field_int (uiout, "number", regnum);
1143 val = get_frame_register_value (frame, regnum);
1145 if (value_optimized_out (val))
1146 error (_("Optimized out"));
1151 char *ptr, buf[1024];
1152 const gdb_byte *valaddr = value_contents_for_printing (val);
1156 for (j = 0; j < register_size (gdbarch, regnum); j++)
1158 int idx = gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG ?
1159 j : register_size (gdbarch, regnum) - 1 - j;
1161 sprintf (ptr, "%02x", (unsigned char) valaddr[idx]);
1164 ui_out_field_string (uiout, "value", buf);
1168 struct value_print_options opts;
1169 struct ui_file *stb;
1170 struct cleanup *old_chain;
1172 stb = mem_fileopen ();
1173 old_chain = make_cleanup_ui_file_delete (stb);
1175 get_formatted_print_options (&opts, format);
1177 val_print (value_type (val),
1178 value_contents_for_printing (val),
1179 value_embedded_offset (val), 0,
1180 stb, 0, val, &opts, current_language);
1181 ui_out_field_stream (uiout, "value", stb);
1182 do_cleanups (old_chain);
1185 do_cleanups (tuple_cleanup);
1188 /* Write given values into registers. The registers and values are
1189 given as pairs. The corresponding MI command is
1190 -data-write-register-values <format>
1191 [<regnum1> <value1>...<regnumN> <valueN>] */
1193 mi_cmd_data_write_register_values (char *command, char **argv, int argc)
1195 struct regcache *regcache;
1196 struct gdbarch *gdbarch;
1199 /* Note that the test for a valid register must include checking the
1200 gdbarch_register_name because gdbarch_num_regs may be allocated
1201 for the union of the register sets within a family of related
1202 processors. In this case, some entries of gdbarch_register_name
1203 will change depending upon the particular processor being
1206 regcache = get_current_regcache ();
1207 gdbarch = get_regcache_arch (regcache);
1208 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
1211 error (_("-data-write-register-values: Usage: -data-write-register-"
1212 "values <format> [<regnum1> <value1>...<regnumN> <valueN>]"));
1214 if (!target_has_registers)
1215 error (_("-data-write-register-values: No registers."));
1218 error (_("-data-write-register-values: No regs and values specified."));
1221 error (_("-data-write-register-values: "
1222 "Regs and vals are not in pairs."));
1224 for (i = 1; i < argc; i = i + 2)
1226 int regnum = atoi (argv[i]);
1228 if (regnum >= 0 && regnum < numregs
1229 && gdbarch_register_name (gdbarch, regnum)
1230 && *gdbarch_register_name (gdbarch, regnum))
1234 /* Get the value as a number. */
1235 value = parse_and_eval_address (argv[i + 1]);
1237 /* Write it down. */
1238 regcache_cooked_write_signed (regcache, regnum, value);
1241 error (_("bad register number"));
1245 /* Evaluate the value of the argument. The argument is an
1246 expression. If the expression contains spaces it needs to be
1247 included in double quotes. */
1250 mi_cmd_data_evaluate_expression (char *command, char **argv, int argc)
1252 struct expression *expr;
1253 struct cleanup *old_chain;
1255 struct ui_file *stb;
1256 struct value_print_options opts;
1257 struct ui_out *uiout = current_uiout;
1259 stb = mem_fileopen ();
1260 old_chain = make_cleanup_ui_file_delete (stb);
1263 error (_("-data-evaluate-expression: "
1264 "Usage: -data-evaluate-expression expression"));
1266 expr = parse_expression (argv[0]);
1268 make_cleanup (free_current_contents, &expr);
1270 val = evaluate_expression (expr);
1272 /* Print the result of the expression evaluation. */
1273 get_user_print_options (&opts);
1275 common_val_print (val, stb, 0, &opts, current_language);
1277 ui_out_field_stream (uiout, "value", stb);
1279 do_cleanups (old_chain);
1282 /* This is the -data-read-memory command.
1284 ADDR: start address of data to be dumped.
1285 WORD-FORMAT: a char indicating format for the ``word''. See
1287 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
1288 NR_ROW: Number of rows.
1289 NR_COL: The number of colums (words per row).
1290 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
1291 ASCHAR for unprintable characters.
1293 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
1294 displayes them. Returns:
1296 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
1299 The number of bytes read is SIZE*ROW*COL. */
1302 mi_cmd_data_read_memory (char *command, char **argv, int argc)
1304 struct gdbarch *gdbarch = get_current_arch ();
1305 struct ui_out *uiout = current_uiout;
1306 struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
1308 long total_bytes, nr_cols, nr_rows;
1310 struct type *word_type;
1323 static const struct mi_opt opts[] =
1325 {"o", OFFSET_OPT, 1},
1331 int opt = mi_getopt ("-data-read-memory", argc, argv, opts,
1336 switch ((enum opt) opt)
1339 offset = atol (oarg);
1346 if (argc < 5 || argc > 6)
1347 error (_("-data-read-memory: Usage: "
1348 "ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR]."));
1350 /* Extract all the arguments. */
1352 /* Start address of the memory dump. */
1353 addr = parse_and_eval_address (argv[0]) + offset;
1354 /* The format character to use when displaying a memory word. See
1355 the ``x'' command. */
1356 word_format = argv[1][0];
1357 /* The size of the memory word. */
1358 word_size = atol (argv[2]);
1362 word_type = builtin_type (gdbarch)->builtin_int8;
1366 word_type = builtin_type (gdbarch)->builtin_int16;
1370 word_type = builtin_type (gdbarch)->builtin_int32;
1374 word_type = builtin_type (gdbarch)->builtin_int64;
1378 word_type = builtin_type (gdbarch)->builtin_int8;
1381 /* The number of rows. */
1382 nr_rows = atol (argv[3]);
1384 error (_("-data-read-memory: invalid number of rows."));
1386 /* Number of bytes per row. */
1387 nr_cols = atol (argv[4]);
1389 error (_("-data-read-memory: invalid number of columns."));
1391 /* The un-printable character when printing ascii. */
1397 /* Create a buffer and read it in. */
1398 total_bytes = word_size * nr_rows * nr_cols;
1399 mbuf = xcalloc (total_bytes, 1);
1400 make_cleanup (xfree, mbuf);
1402 /* Dispatch memory reads to the topmost target, not the flattened
1404 nr_bytes = target_read (current_target.beneath,
1405 TARGET_OBJECT_MEMORY, NULL, mbuf,
1408 error (_("Unable to read memory."));
1410 /* Output the header information. */
1411 ui_out_field_core_addr (uiout, "addr", gdbarch, addr);
1412 ui_out_field_int (uiout, "nr-bytes", nr_bytes);
1413 ui_out_field_int (uiout, "total-bytes", total_bytes);
1414 ui_out_field_core_addr (uiout, "next-row",
1415 gdbarch, addr + word_size * nr_cols);
1416 ui_out_field_core_addr (uiout, "prev-row",
1417 gdbarch, addr - word_size * nr_cols);
1418 ui_out_field_core_addr (uiout, "next-page", gdbarch, addr + total_bytes);
1419 ui_out_field_core_addr (uiout, "prev-page", gdbarch, addr - total_bytes);
1421 /* Build the result as a two dimentional table. */
1423 struct ui_file *stream;
1424 struct cleanup *cleanup_stream;
1428 stream = mem_fileopen ();
1429 cleanup_stream = make_cleanup_ui_file_delete (stream);
1431 make_cleanup_ui_out_list_begin_end (uiout, "memory");
1432 for (row = 0, row_byte = 0;
1434 row++, row_byte += nr_cols * word_size)
1438 struct cleanup *cleanup_tuple;
1439 struct cleanup *cleanup_list_data;
1440 struct value_print_options opts;
1442 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1443 ui_out_field_core_addr (uiout, "addr", gdbarch, addr + row_byte);
1444 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr +
1446 cleanup_list_data = make_cleanup_ui_out_list_begin_end (uiout, "data");
1447 get_formatted_print_options (&opts, word_format);
1448 for (col = 0, col_byte = row_byte;
1450 col++, col_byte += word_size)
1452 if (col_byte + word_size > nr_bytes)
1454 ui_out_field_string (uiout, NULL, "N/A");
1458 ui_file_rewind (stream);
1459 print_scalar_formatted (mbuf + col_byte, word_type, &opts,
1460 word_asize, stream);
1461 ui_out_field_stream (uiout, NULL, stream);
1464 do_cleanups (cleanup_list_data);
1469 ui_file_rewind (stream);
1470 for (byte = row_byte;
1471 byte < row_byte + word_size * nr_cols; byte++)
1473 if (byte >= nr_bytes)
1474 fputc_unfiltered ('X', stream);
1475 else if (mbuf[byte] < 32 || mbuf[byte] > 126)
1476 fputc_unfiltered (aschar, stream);
1478 fputc_unfiltered (mbuf[byte], stream);
1480 ui_out_field_stream (uiout, "ascii", stream);
1482 do_cleanups (cleanup_tuple);
1484 do_cleanups (cleanup_stream);
1486 do_cleanups (cleanups);
1490 mi_cmd_data_read_memory_bytes (char *command, char **argv, int argc)
1492 struct gdbarch *gdbarch = get_current_arch ();
1493 struct ui_out *uiout = current_uiout;
1494 struct cleanup *cleanups;
1497 memory_read_result_s *read_result;
1499 VEC(memory_read_result_s) *result;
1507 static const struct mi_opt opts[] =
1509 {"o", OFFSET_OPT, 1},
1515 int opt = mi_getopt ("-data-read-memory-bytes", argc, argv, opts,
1519 switch ((enum opt) opt)
1522 offset = atol (oarg);
1530 error (_("Usage: [ -o OFFSET ] ADDR LENGTH."));
1532 addr = parse_and_eval_address (argv[0]) + offset;
1533 length = atol (argv[1]);
1535 result = read_memory_robust (current_target.beneath, addr, length);
1537 cleanups = make_cleanup (free_memory_read_result_vector, result);
1539 if (VEC_length (memory_read_result_s, result) == 0)
1540 error (_("Unable to read memory."));
1542 make_cleanup_ui_out_list_begin_end (uiout, "memory");
1544 VEC_iterate (memory_read_result_s, result, ix, read_result);
1547 struct cleanup *t = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1551 ui_out_field_core_addr (uiout, "begin", gdbarch, read_result->begin);
1552 ui_out_field_core_addr (uiout, "offset", gdbarch, read_result->begin
1554 ui_out_field_core_addr (uiout, "end", gdbarch, read_result->end);
1556 data = xmalloc ((read_result->end - read_result->begin) * 2 + 1);
1558 for (i = 0, p = data;
1559 i < (read_result->end - read_result->begin);
1562 sprintf (p, "%02x", read_result->data[i]);
1564 ui_out_field_string (uiout, "contents", data);
1568 do_cleanups (cleanups);
1571 /* Implementation of the -data-write_memory command.
1573 COLUMN_OFFSET: optional argument. Must be preceded by '-o'. The
1574 offset from the beginning of the memory grid row where the cell to
1576 ADDR: start address of the row in the memory grid where the memory
1577 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
1578 the location to write to.
1579 FORMAT: a char indicating format for the ``word''. See
1581 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
1582 VALUE: value to be written into the memory address.
1584 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1589 mi_cmd_data_write_memory (char *command, char **argv, int argc)
1591 struct gdbarch *gdbarch = get_current_arch ();
1592 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1595 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1596 enough when using a compiler other than GCC. */
1599 struct cleanup *old_chain;
1607 static const struct mi_opt opts[] =
1609 {"o", OFFSET_OPT, 1},
1615 int opt = mi_getopt ("-data-write-memory", argc, argv, opts,
1620 switch ((enum opt) opt)
1623 offset = atol (oarg);
1631 error (_("-data-write-memory: Usage: "
1632 "[-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE."));
1634 /* Extract all the arguments. */
1635 /* Start address of the memory dump. */
1636 addr = parse_and_eval_address (argv[0]);
1637 /* The size of the memory word. */
1638 word_size = atol (argv[2]);
1640 /* Calculate the real address of the write destination. */
1641 addr += (offset * word_size);
1643 /* Get the value as a number. */
1644 value = parse_and_eval_address (argv[3]);
1645 /* Get the value into an array. */
1646 buffer = xmalloc (word_size);
1647 old_chain = make_cleanup (xfree, buffer);
1648 store_signed_integer (buffer, word_size, byte_order, value);
1649 /* Write it down to memory. */
1650 write_memory_with_notification (addr, buffer, word_size);
1651 /* Free the buffer. */
1652 do_cleanups (old_chain);
1655 /* Implementation of the -data-write-memory-bytes command.
1658 DATA: string of bytes to write at that address
1659 COUNT: number of bytes to be filled (decimal integer). */
1662 mi_cmd_data_write_memory_bytes (char *command, char **argv, int argc)
1668 size_t len, i, steps, remainder;
1670 struct cleanup *back_to;
1672 if (argc != 2 && argc != 3)
1673 error (_("Usage: ADDR DATA [COUNT]."));
1675 addr = parse_and_eval_address (argv[0]);
1677 if (strlen (cdata) % 2)
1678 error (_("Hex-encoded '%s' must have an even number of characters."),
1681 len = strlen (cdata)/2;
1683 count = strtoul (argv[2], NULL, 10);
1687 databuf = xmalloc (len * sizeof (gdb_byte));
1688 back_to = make_cleanup (xfree, databuf);
1690 for (i = 0; i < len; ++i)
1693 if (sscanf (cdata + i * 2, "%02x", &x) != 1)
1694 error (_("Invalid argument"));
1695 databuf[i] = (gdb_byte) x;
1700 /* Pattern is made of less bytes than count:
1701 repeat pattern to fill memory. */
1702 data = xmalloc (count);
1703 make_cleanup (xfree, data);
1705 steps = count / len;
1706 remainder = count % len;
1707 for (j = 0; j < steps; j++)
1708 memcpy (data + j * len, databuf, len);
1711 memcpy (data + steps * len, databuf, remainder);
1715 /* Pattern is longer than or equal to count:
1716 just copy len bytes. */
1720 write_memory_with_notification (addr, data, count);
1722 do_cleanups (back_to);
1726 mi_cmd_enable_timings (char *command, char **argv, int argc)
1732 if (strcmp (argv[0], "yes") == 0)
1734 else if (strcmp (argv[0], "no") == 0)
1745 error (_("-enable-timings: Usage: %s {yes|no}"), command);
1749 mi_cmd_list_features (char *command, char **argv, int argc)
1753 struct cleanup *cleanup = NULL;
1754 struct ui_out *uiout = current_uiout;
1756 cleanup = make_cleanup_ui_out_list_begin_end (uiout, "features");
1757 ui_out_field_string (uiout, NULL, "frozen-varobjs");
1758 ui_out_field_string (uiout, NULL, "pending-breakpoints");
1759 ui_out_field_string (uiout, NULL, "thread-info");
1760 ui_out_field_string (uiout, NULL, "data-read-memory-bytes");
1761 ui_out_field_string (uiout, NULL, "breakpoint-notifications");
1762 ui_out_field_string (uiout, NULL, "ada-task-info");
1765 if (gdb_python_initialized)
1766 ui_out_field_string (uiout, NULL, "python");
1769 do_cleanups (cleanup);
1773 error (_("-list-features should be passed no arguments"));
1777 mi_cmd_list_target_features (char *command, char **argv, int argc)
1781 struct cleanup *cleanup = NULL;
1782 struct ui_out *uiout = current_uiout;
1784 cleanup = make_cleanup_ui_out_list_begin_end (uiout, "features");
1785 if (target_can_async_p ())
1786 ui_out_field_string (uiout, NULL, "async");
1787 if (target_can_execute_reverse)
1788 ui_out_field_string (uiout, NULL, "reverse");
1790 do_cleanups (cleanup);
1794 error (_("-list-target-features should be passed no arguments"));
1798 mi_cmd_add_inferior (char *command, char **argv, int argc)
1800 struct inferior *inf;
1803 error (_("-add-inferior should be passed no arguments"));
1805 inf = add_inferior_with_spaces ();
1807 ui_out_field_fmt (current_uiout, "inferior", "i%d", inf->num);
1810 /* Callback used to find the first inferior other than the current
1814 get_other_inferior (struct inferior *inf, void *arg)
1816 if (inf == current_inferior ())
1823 mi_cmd_remove_inferior (char *command, char **argv, int argc)
1826 struct inferior *inf;
1829 error (_("-remove-inferior should be passed a single argument"));
1831 if (sscanf (argv[0], "i%d", &id) != 1)
1832 error (_("the thread group id is syntactically invalid"));
1834 inf = find_inferior_id (id);
1836 error (_("the specified thread group does not exist"));
1839 error (_("cannot remove an active inferior"));
1841 if (inf == current_inferior ())
1843 struct thread_info *tp = 0;
1844 struct inferior *new_inferior
1845 = iterate_over_inferiors (get_other_inferior, NULL);
1847 if (new_inferior == NULL)
1848 error (_("Cannot remove last inferior"));
1850 set_current_inferior (new_inferior);
1851 if (new_inferior->pid != 0)
1852 tp = any_thread_of_process (new_inferior->pid);
1853 switch_to_thread (tp ? tp->ptid : null_ptid);
1854 set_current_program_space (new_inferior->pspace);
1857 delete_inferior_1 (inf, 1 /* silent */);
1862 /* Execute a command within a safe environment.
1863 Return <0 for error; >=0 for ok.
1865 args->action will tell mi_execute_command what action
1866 to perfrom after the given command has executed (display/suppress
1867 prompt, display error). */
1870 captured_mi_execute_command (struct ui_out *uiout, struct mi_parse *context)
1872 struct cleanup *cleanup;
1875 current_command_ts = context->cmd_start;
1877 current_token = xstrdup (context->token);
1878 cleanup = make_cleanup (free_current_contents, ¤t_token);
1880 running_result_record_printed = 0;
1882 switch (context->op)
1885 /* A MI command was read from the input stream. */
1887 /* FIXME: gdb_???? */
1888 fprintf_unfiltered (raw_stdout, " token=`%s' command=`%s' args=`%s'\n",
1889 context->token, context->command, context->args);
1891 mi_cmd_execute (context);
1893 /* Print the result if there were no errors.
1895 Remember that on the way out of executing a command, you have
1896 to directly use the mi_interp's uiout, since the command
1897 could have reset the interpreter, in which case the current
1898 uiout will most likely crash in the mi_out_* routines. */
1899 if (!running_result_record_printed)
1901 fputs_unfiltered (context->token, raw_stdout);
1902 /* There's no particularly good reason why target-connect results
1903 in not ^done. Should kill ^connected for MI3. */
1904 fputs_unfiltered (strcmp (context->command, "target-select") == 0
1905 ? "^connected" : "^done", raw_stdout);
1906 mi_out_put (uiout, raw_stdout);
1907 mi_out_rewind (uiout);
1908 mi_print_timing_maybe ();
1909 fputs_unfiltered ("\n", raw_stdout);
1912 /* The command does not want anything to be printed. In that
1913 case, the command probably should not have written anything
1914 to uiout, but in case it has written something, discard it. */
1915 mi_out_rewind (uiout);
1922 /* A CLI command was read from the input stream. */
1923 /* This "feature" will be removed as soon as we have a
1924 complete set of mi commands. */
1925 /* Echo the command on the console. */
1926 fprintf_unfiltered (gdb_stdlog, "%s\n", context->command);
1927 /* Call the "console" interpreter. */
1928 argv[0] = "console";
1929 argv[1] = context->command;
1930 mi_cmd_interpreter_exec ("-interpreter-exec", argv, 2);
1932 /* If we changed interpreters, DON'T print out anything. */
1933 if (current_interp_named_p (INTERP_MI)
1934 || current_interp_named_p (INTERP_MI1)
1935 || current_interp_named_p (INTERP_MI2)
1936 || current_interp_named_p (INTERP_MI3))
1938 if (!running_result_record_printed)
1940 fputs_unfiltered (context->token, raw_stdout);
1941 fputs_unfiltered ("^done", raw_stdout);
1942 mi_out_put (uiout, raw_stdout);
1943 mi_out_rewind (uiout);
1944 mi_print_timing_maybe ();
1945 fputs_unfiltered ("\n", raw_stdout);
1948 mi_out_rewind (uiout);
1954 do_cleanups (cleanup);
1957 /* Print a gdb exception to the MI output stream. */
1960 mi_print_exception (const char *token, struct gdb_exception exception)
1962 fputs_unfiltered (token, raw_stdout);
1963 fputs_unfiltered ("^error,msg=\"", raw_stdout);
1964 if (exception.message == NULL)
1965 fputs_unfiltered ("unknown error", raw_stdout);
1967 fputstr_unfiltered (exception.message, '"', raw_stdout);
1968 fputs_unfiltered ("\"\n", raw_stdout);
1972 mi_execute_command (const char *cmd, int from_tty)
1975 struct mi_parse *command = NULL;
1976 volatile struct gdb_exception exception;
1978 /* This is to handle EOF (^D). We just quit gdb. */
1979 /* FIXME: we should call some API function here. */
1981 quit_force (NULL, from_tty);
1983 target_log_command (cmd);
1985 TRY_CATCH (exception, RETURN_MASK_ALL)
1987 command = mi_parse (cmd, &token);
1989 if (exception.reason < 0)
1991 mi_print_exception (token, exception);
1996 volatile struct gdb_exception result;
1997 ptid_t previous_ptid = inferior_ptid;
1999 command->token = token;
2003 command->cmd_start = (struct mi_timestamp *)
2004 xmalloc (sizeof (struct mi_timestamp));
2005 timestamp (command->cmd_start);
2008 TRY_CATCH (result, RETURN_MASK_ALL)
2010 captured_mi_execute_command (current_uiout, command);
2012 if (result.reason < 0)
2014 /* The command execution failed and error() was called
2016 mi_print_exception (command->token, result);
2017 mi_out_rewind (current_uiout);
2020 bpstat_do_actions ();
2022 if (/* The notifications are only output when the top-level
2023 interpreter (specified on the command line) is MI. */
2024 ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ()))
2025 /* Don't try report anything if there are no threads --
2026 the program is dead. */
2027 && thread_count () != 0
2028 /* -thread-select explicitly changes thread. If frontend uses that
2029 internally, we don't want to emit =thread-selected, since
2030 =thread-selected is supposed to indicate user's intentions. */
2031 && strcmp (command->command, "thread-select") != 0)
2033 struct mi_interp *mi = top_level_interpreter_data ();
2034 int report_change = 0;
2036 if (command->thread == -1)
2038 report_change = (!ptid_equal (previous_ptid, null_ptid)
2039 && !ptid_equal (inferior_ptid, previous_ptid)
2040 && !ptid_equal (inferior_ptid, null_ptid));
2042 else if (!ptid_equal (inferior_ptid, null_ptid))
2044 struct thread_info *ti = inferior_thread ();
2046 report_change = (ti->num != command->thread);
2051 struct thread_info *ti = inferior_thread ();
2053 target_terminal_ours ();
2054 fprintf_unfiltered (mi->event_channel,
2055 "thread-selected,id=\"%d\"",
2057 gdb_flush (mi->event_channel);
2061 mi_parse_free (command);
2066 mi_cmd_execute (struct mi_parse *parse)
2068 struct cleanup *cleanup;
2070 cleanup = prepare_execute_command ();
2072 if (parse->all && parse->thread_group != -1)
2073 error (_("Cannot specify --thread-group together with --all"));
2075 if (parse->all && parse->thread != -1)
2076 error (_("Cannot specify --thread together with --all"));
2078 if (parse->thread_group != -1 && parse->thread != -1)
2079 error (_("Cannot specify --thread together with --thread-group"));
2081 if (parse->frame != -1 && parse->thread == -1)
2082 error (_("Cannot specify --frame without --thread"));
2084 if (parse->thread_group != -1)
2086 struct inferior *inf = find_inferior_id (parse->thread_group);
2087 struct thread_info *tp = 0;
2090 error (_("Invalid thread group for the --thread-group option"));
2092 set_current_inferior (inf);
2093 /* This behaviour means that if --thread-group option identifies
2094 an inferior with multiple threads, then a random one will be
2095 picked. This is not a problem -- frontend should always
2096 provide --thread if it wishes to operate on a specific
2099 tp = any_live_thread_of_process (inf->pid);
2100 switch_to_thread (tp ? tp->ptid : null_ptid);
2101 set_current_program_space (inf->pspace);
2104 if (parse->thread != -1)
2106 struct thread_info *tp = find_thread_id (parse->thread);
2109 error (_("Invalid thread id: %d"), parse->thread);
2111 if (is_exited (tp->ptid))
2112 error (_("Thread id: %d has terminated"), parse->thread);
2114 switch_to_thread (tp->ptid);
2117 if (parse->frame != -1)
2119 struct frame_info *fid;
2120 int frame = parse->frame;
2122 fid = find_relative_frame (get_current_frame (), &frame);
2124 /* find_relative_frame was successful */
2127 error (_("Invalid frame id: %d"), frame);
2130 current_context = parse;
2132 if (parse->cmd->suppress_notification != NULL)
2134 make_cleanup_restore_integer (parse->cmd->suppress_notification);
2135 *parse->cmd->suppress_notification = 1;
2138 if (parse->cmd->argv_func != NULL)
2140 parse->cmd->argv_func (parse->command, parse->argv, parse->argc);
2142 else if (parse->cmd->cli.cmd != 0)
2144 /* FIXME: DELETE THIS. */
2145 /* The operation is still implemented by a cli command. */
2146 /* Must be a synchronous one. */
2147 mi_execute_cli_command (parse->cmd->cli.cmd, parse->cmd->cli.args_p,
2152 /* FIXME: DELETE THIS. */
2153 struct ui_file *stb;
2155 stb = mem_fileopen ();
2157 fputs_unfiltered ("Undefined mi command: ", stb);
2158 fputstr_unfiltered (parse->command, '"', stb);
2159 fputs_unfiltered (" (missing implementation)", stb);
2161 make_cleanup_ui_file_delete (stb);
2164 do_cleanups (cleanup);
2167 /* FIXME: This is just a hack so we can get some extra commands going.
2168 We don't want to channel things through the CLI, but call libgdb directly.
2169 Use only for synchronous commands. */
2172 mi_execute_cli_command (const char *cmd, int args_p, const char *args)
2176 struct cleanup *old_cleanups;
2180 run = xstrprintf ("%s %s", cmd, args);
2182 run = xstrdup (cmd);
2184 /* FIXME: gdb_???? */
2185 fprintf_unfiltered (gdb_stdout, "cli=%s run=%s\n",
2187 old_cleanups = make_cleanup (xfree, run);
2188 execute_command (run, 0 /* from_tty */ );
2189 do_cleanups (old_cleanups);
2195 mi_execute_async_cli_command (char *cli_command, char **argv, int argc)
2197 struct cleanup *old_cleanups;
2200 if (target_can_async_p ())
2201 run = xstrprintf ("%s %s&", cli_command, argc ? *argv : "");
2203 run = xstrprintf ("%s %s", cli_command, argc ? *argv : "");
2204 old_cleanups = make_cleanup (xfree, run);
2206 execute_command (run, 0 /* from_tty */ );
2208 /* Do this before doing any printing. It would appear that some
2209 print code leaves garbage around in the buffer. */
2210 do_cleanups (old_cleanups);
2214 mi_load_progress (const char *section_name,
2215 unsigned long sent_so_far,
2216 unsigned long total_section,
2217 unsigned long total_sent,
2218 unsigned long grand_total)
2220 struct timeval time_now, delta, update_threshold;
2221 static struct timeval last_update;
2222 static char *previous_sect_name = NULL;
2224 struct ui_out *saved_uiout;
2225 struct ui_out *uiout;
2227 /* This function is called through deprecated_show_load_progress
2228 which means uiout may not be correct. Fix it for the duration
2229 of this function. */
2230 saved_uiout = current_uiout;
2232 if (current_interp_named_p (INTERP_MI)
2233 || current_interp_named_p (INTERP_MI2))
2234 current_uiout = mi_out_new (2);
2235 else if (current_interp_named_p (INTERP_MI1))
2236 current_uiout = mi_out_new (1);
2237 else if (current_interp_named_p (INTERP_MI3))
2238 current_uiout = mi_out_new (3);
2242 uiout = current_uiout;
2244 update_threshold.tv_sec = 0;
2245 update_threshold.tv_usec = 500000;
2246 gettimeofday (&time_now, NULL);
2248 delta.tv_usec = time_now.tv_usec - last_update.tv_usec;
2249 delta.tv_sec = time_now.tv_sec - last_update.tv_sec;
2251 if (delta.tv_usec < 0)
2254 delta.tv_usec += 1000000L;
2257 new_section = (previous_sect_name ?
2258 strcmp (previous_sect_name, section_name) : 1);
2261 struct cleanup *cleanup_tuple;
2263 xfree (previous_sect_name);
2264 previous_sect_name = xstrdup (section_name);
2267 fputs_unfiltered (current_token, raw_stdout);
2268 fputs_unfiltered ("+download", raw_stdout);
2269 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
2270 ui_out_field_string (uiout, "section", section_name);
2271 ui_out_field_int (uiout, "section-size", total_section);
2272 ui_out_field_int (uiout, "total-size", grand_total);
2273 do_cleanups (cleanup_tuple);
2274 mi_out_put (uiout, raw_stdout);
2275 fputs_unfiltered ("\n", raw_stdout);
2276 gdb_flush (raw_stdout);
2279 if (delta.tv_sec >= update_threshold.tv_sec &&
2280 delta.tv_usec >= update_threshold.tv_usec)
2282 struct cleanup *cleanup_tuple;
2284 last_update.tv_sec = time_now.tv_sec;
2285 last_update.tv_usec = time_now.tv_usec;
2287 fputs_unfiltered (current_token, raw_stdout);
2288 fputs_unfiltered ("+download", raw_stdout);
2289 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
2290 ui_out_field_string (uiout, "section", section_name);
2291 ui_out_field_int (uiout, "section-sent", sent_so_far);
2292 ui_out_field_int (uiout, "section-size", total_section);
2293 ui_out_field_int (uiout, "total-sent", total_sent);
2294 ui_out_field_int (uiout, "total-size", grand_total);
2295 do_cleanups (cleanup_tuple);
2296 mi_out_put (uiout, raw_stdout);
2297 fputs_unfiltered ("\n", raw_stdout);
2298 gdb_flush (raw_stdout);
2302 current_uiout = saved_uiout;
2306 timestamp (struct mi_timestamp *tv)
2308 gettimeofday (&tv->wallclock, NULL);
2309 #ifdef HAVE_GETRUSAGE
2310 getrusage (RUSAGE_SELF, &rusage);
2311 tv->utime.tv_sec = rusage.ru_utime.tv_sec;
2312 tv->utime.tv_usec = rusage.ru_utime.tv_usec;
2313 tv->stime.tv_sec = rusage.ru_stime.tv_sec;
2314 tv->stime.tv_usec = rusage.ru_stime.tv_usec;
2317 long usec = get_run_time ();
2319 tv->utime.tv_sec = usec/1000000L;
2320 tv->utime.tv_usec = usec - 1000000L*tv->utime.tv_sec;
2321 tv->stime.tv_sec = 0;
2322 tv->stime.tv_usec = 0;
2328 print_diff_now (struct mi_timestamp *start)
2330 struct mi_timestamp now;
2333 print_diff (start, &now);
2337 mi_print_timing_maybe (void)
2339 /* If the command is -enable-timing then do_timings may be true
2340 whilst current_command_ts is not initialized. */
2341 if (do_timings && current_command_ts)
2342 print_diff_now (current_command_ts);
2346 timeval_diff (struct timeval start, struct timeval end)
2348 return ((end.tv_sec - start.tv_sec) * 1000000L)
2349 + (end.tv_usec - start.tv_usec);
2353 print_diff (struct mi_timestamp *start, struct mi_timestamp *end)
2357 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
2358 timeval_diff (start->wallclock, end->wallclock) / 1000000.0,
2359 timeval_diff (start->utime, end->utime) / 1000000.0,
2360 timeval_diff (start->stime, end->stime) / 1000000.0);
2364 mi_cmd_trace_define_variable (char *command, char **argv, int argc)
2366 struct expression *expr;
2367 LONGEST initval = 0;
2368 struct trace_state_variable *tsv;
2371 if (argc != 1 && argc != 2)
2372 error (_("Usage: -trace-define-variable VARIABLE [VALUE]"));
2376 error (_("Name of trace variable should start with '$'"));
2378 validate_trace_state_variable_name (name);
2380 tsv = find_trace_state_variable (name);
2382 tsv = create_trace_state_variable (name);
2385 initval = value_as_long (parse_and_eval (argv[1]));
2387 tsv->initial_value = initval;
2391 mi_cmd_trace_list_variables (char *command, char **argv, int argc)
2394 error (_("-trace-list-variables: no arguments allowed"));
2396 tvariables_info_1 ();
2400 mi_cmd_trace_find (char *command, char **argv, int argc)
2405 error (_("trace selection mode is required"));
2409 if (strcmp (mode, "none") == 0)
2411 tfind_1 (tfind_number, -1, 0, 0, 0);
2415 if (current_trace_status ()->running)
2416 error (_("May not look at trace frames while trace is running."));
2418 if (strcmp (mode, "frame-number") == 0)
2421 error (_("frame number is required"));
2422 tfind_1 (tfind_number, atoi (argv[1]), 0, 0, 0);
2424 else if (strcmp (mode, "tracepoint-number") == 0)
2427 error (_("tracepoint number is required"));
2428 tfind_1 (tfind_tp, atoi (argv[1]), 0, 0, 0);
2430 else if (strcmp (mode, "pc") == 0)
2433 error (_("PC is required"));
2434 tfind_1 (tfind_pc, 0, parse_and_eval_address (argv[1]), 0, 0);
2436 else if (strcmp (mode, "pc-inside-range") == 0)
2439 error (_("Start and end PC are required"));
2440 tfind_1 (tfind_range, 0, parse_and_eval_address (argv[1]),
2441 parse_and_eval_address (argv[2]), 0);
2443 else if (strcmp (mode, "pc-outside-range") == 0)
2446 error (_("Start and end PC are required"));
2447 tfind_1 (tfind_outside, 0, parse_and_eval_address (argv[1]),
2448 parse_and_eval_address (argv[2]), 0);
2450 else if (strcmp (mode, "line") == 0)
2452 struct symtabs_and_lines sals;
2453 struct symtab_and_line sal;
2454 static CORE_ADDR start_pc, end_pc;
2455 struct cleanup *back_to;
2458 error (_("Line is required"));
2460 sals = decode_line_with_current_source (argv[1],
2461 DECODE_LINE_FUNFIRSTLINE);
2462 back_to = make_cleanup (xfree, sals.sals);
2466 if (sal.symtab == 0)
2467 error (_("Could not find the specified line"));
2469 if (sal.line > 0 && find_line_pc_range (sal, &start_pc, &end_pc))
2470 tfind_1 (tfind_range, 0, start_pc, end_pc - 1, 0);
2472 error (_("Could not find the specified line"));
2474 do_cleanups (back_to);
2477 error (_("Invalid mode '%s'"), mode);
2479 if (has_stack_frames () || get_traceframe_number () >= 0)
2480 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
2484 mi_cmd_trace_save (char *command, char **argv, int argc)
2486 int target_saves = 0;
2487 int generate_ctf = 0;
2494 TARGET_SAVE_OPT, CTF_OPT
2496 static const struct mi_opt opts[] =
2498 {"r", TARGET_SAVE_OPT, 0},
2499 {"ctf", CTF_OPT, 0},
2505 int opt = mi_getopt ("-trace-save", argc, argv, opts,
2510 switch ((enum opt) opt)
2512 case TARGET_SAVE_OPT:
2520 filename = argv[oind];
2523 trace_save_ctf (filename, target_saves);
2525 trace_save_tfile (filename, target_saves);
2529 mi_cmd_trace_start (char *command, char **argv, int argc)
2531 start_tracing (NULL);
2535 mi_cmd_trace_status (char *command, char **argv, int argc)
2537 trace_status_mi (0);
2541 mi_cmd_trace_stop (char *command, char **argv, int argc)
2543 stop_tracing (NULL);
2544 trace_status_mi (1);
2547 /* Implement the "-ada-task-info" command. */
2550 mi_cmd_ada_task_info (char *command, char **argv, int argc)
2552 if (argc != 0 && argc != 1)
2553 error (_("Invalid MI command"));
2555 print_ada_task_info (current_uiout, argv[0], current_inferior ());