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 get_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, *tuple_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')
1106 tuple_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1107 ui_out_field_int (uiout, "number", regnum);
1108 get_register (frame, regnum, format);
1109 do_cleanups (tuple_cleanup);
1113 /* Else, list of register #s, just do listed regs. */
1114 for (i = 1; i < argc; i++)
1116 regnum = atoi (argv[i]);
1120 && gdbarch_register_name (gdbarch, regnum) != NULL
1121 && *gdbarch_register_name (gdbarch, regnum) != '\000')
1123 tuple_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1124 ui_out_field_int (uiout, "number", regnum);
1125 get_register (frame, regnum, format);
1126 do_cleanups (tuple_cleanup);
1129 error (_("bad register number"));
1131 do_cleanups (list_cleanup);
1134 /* Output one register's contents in the desired format. */
1137 get_register (struct frame_info *frame, int regnum, int format)
1139 struct gdbarch *gdbarch = get_frame_arch (frame);
1140 struct ui_out *uiout = current_uiout;
1146 val = get_frame_register_value (frame, regnum);
1148 if (value_optimized_out (val))
1149 error (_("Optimized out"));
1154 char *ptr, buf[1024];
1155 const gdb_byte *valaddr = value_contents_for_printing (val);
1159 for (j = 0; j < register_size (gdbarch, regnum); j++)
1161 int idx = gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG ?
1162 j : register_size (gdbarch, regnum) - 1 - j;
1164 sprintf (ptr, "%02x", (unsigned char) valaddr[idx]);
1167 ui_out_field_string (uiout, "value", buf);
1171 struct value_print_options opts;
1172 struct ui_file *stb;
1173 struct cleanup *old_chain;
1175 stb = mem_fileopen ();
1176 old_chain = make_cleanup_ui_file_delete (stb);
1178 get_formatted_print_options (&opts, format);
1180 val_print (value_type (val),
1181 value_contents_for_printing (val),
1182 value_embedded_offset (val), 0,
1183 stb, 0, val, &opts, current_language);
1184 ui_out_field_stream (uiout, "value", stb);
1185 do_cleanups (old_chain);
1189 /* Write given values into registers. The registers and values are
1190 given as pairs. The corresponding MI command is
1191 -data-write-register-values <format>
1192 [<regnum1> <value1>...<regnumN> <valueN>] */
1194 mi_cmd_data_write_register_values (char *command, char **argv, int argc)
1196 struct regcache *regcache;
1197 struct gdbarch *gdbarch;
1200 /* Note that the test for a valid register must include checking the
1201 gdbarch_register_name because gdbarch_num_regs may be allocated
1202 for the union of the register sets within a family of related
1203 processors. In this case, some entries of gdbarch_register_name
1204 will change depending upon the particular processor being
1207 regcache = get_current_regcache ();
1208 gdbarch = get_regcache_arch (regcache);
1209 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
1212 error (_("-data-write-register-values: Usage: -data-write-register-"
1213 "values <format> [<regnum1> <value1>...<regnumN> <valueN>]"));
1215 if (!target_has_registers)
1216 error (_("-data-write-register-values: No registers."));
1219 error (_("-data-write-register-values: No regs and values specified."));
1222 error (_("-data-write-register-values: "
1223 "Regs and vals are not in pairs."));
1225 for (i = 1; i < argc; i = i + 2)
1227 int regnum = atoi (argv[i]);
1229 if (regnum >= 0 && regnum < numregs
1230 && gdbarch_register_name (gdbarch, regnum)
1231 && *gdbarch_register_name (gdbarch, regnum))
1235 /* Get the value as a number. */
1236 value = parse_and_eval_address (argv[i + 1]);
1238 /* Write it down. */
1239 regcache_cooked_write_signed (regcache, regnum, value);
1242 error (_("bad register number"));
1246 /* Evaluate the value of the argument. The argument is an
1247 expression. If the expression contains spaces it needs to be
1248 included in double quotes. */
1251 mi_cmd_data_evaluate_expression (char *command, char **argv, int argc)
1253 struct expression *expr;
1254 struct cleanup *old_chain;
1256 struct ui_file *stb;
1257 struct value_print_options opts;
1258 struct ui_out *uiout = current_uiout;
1260 stb = mem_fileopen ();
1261 old_chain = make_cleanup_ui_file_delete (stb);
1264 error (_("-data-evaluate-expression: "
1265 "Usage: -data-evaluate-expression expression"));
1267 expr = parse_expression (argv[0]);
1269 make_cleanup (free_current_contents, &expr);
1271 val = evaluate_expression (expr);
1273 /* Print the result of the expression evaluation. */
1274 get_user_print_options (&opts);
1276 common_val_print (val, stb, 0, &opts, current_language);
1278 ui_out_field_stream (uiout, "value", stb);
1280 do_cleanups (old_chain);
1283 /* This is the -data-read-memory command.
1285 ADDR: start address of data to be dumped.
1286 WORD-FORMAT: a char indicating format for the ``word''. See
1288 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
1289 NR_ROW: Number of rows.
1290 NR_COL: The number of colums (words per row).
1291 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
1292 ASCHAR for unprintable characters.
1294 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
1295 displayes them. Returns:
1297 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
1300 The number of bytes read is SIZE*ROW*COL. */
1303 mi_cmd_data_read_memory (char *command, char **argv, int argc)
1305 struct gdbarch *gdbarch = get_current_arch ();
1306 struct ui_out *uiout = current_uiout;
1307 struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
1309 long total_bytes, nr_cols, nr_rows;
1311 struct type *word_type;
1324 static const struct mi_opt opts[] =
1326 {"o", OFFSET_OPT, 1},
1332 int opt = mi_getopt ("-data-read-memory", argc, argv, opts,
1337 switch ((enum opt) opt)
1340 offset = atol (oarg);
1347 if (argc < 5 || argc > 6)
1348 error (_("-data-read-memory: Usage: "
1349 "ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR]."));
1351 /* Extract all the arguments. */
1353 /* Start address of the memory dump. */
1354 addr = parse_and_eval_address (argv[0]) + offset;
1355 /* The format character to use when displaying a memory word. See
1356 the ``x'' command. */
1357 word_format = argv[1][0];
1358 /* The size of the memory word. */
1359 word_size = atol (argv[2]);
1363 word_type = builtin_type (gdbarch)->builtin_int8;
1367 word_type = builtin_type (gdbarch)->builtin_int16;
1371 word_type = builtin_type (gdbarch)->builtin_int32;
1375 word_type = builtin_type (gdbarch)->builtin_int64;
1379 word_type = builtin_type (gdbarch)->builtin_int8;
1382 /* The number of rows. */
1383 nr_rows = atol (argv[3]);
1385 error (_("-data-read-memory: invalid number of rows."));
1387 /* Number of bytes per row. */
1388 nr_cols = atol (argv[4]);
1390 error (_("-data-read-memory: invalid number of columns."));
1392 /* The un-printable character when printing ascii. */
1398 /* Create a buffer and read it in. */
1399 total_bytes = word_size * nr_rows * nr_cols;
1400 mbuf = xcalloc (total_bytes, 1);
1401 make_cleanup (xfree, mbuf);
1403 /* Dispatch memory reads to the topmost target, not the flattened
1405 nr_bytes = target_read (current_target.beneath,
1406 TARGET_OBJECT_MEMORY, NULL, mbuf,
1409 error (_("Unable to read memory."));
1411 /* Output the header information. */
1412 ui_out_field_core_addr (uiout, "addr", gdbarch, addr);
1413 ui_out_field_int (uiout, "nr-bytes", nr_bytes);
1414 ui_out_field_int (uiout, "total-bytes", total_bytes);
1415 ui_out_field_core_addr (uiout, "next-row",
1416 gdbarch, addr + word_size * nr_cols);
1417 ui_out_field_core_addr (uiout, "prev-row",
1418 gdbarch, addr - word_size * nr_cols);
1419 ui_out_field_core_addr (uiout, "next-page", gdbarch, addr + total_bytes);
1420 ui_out_field_core_addr (uiout, "prev-page", gdbarch, addr - total_bytes);
1422 /* Build the result as a two dimentional table. */
1424 struct ui_file *stream;
1425 struct cleanup *cleanup_stream;
1429 stream = mem_fileopen ();
1430 cleanup_stream = make_cleanup_ui_file_delete (stream);
1432 make_cleanup_ui_out_list_begin_end (uiout, "memory");
1433 for (row = 0, row_byte = 0;
1435 row++, row_byte += nr_cols * word_size)
1439 struct cleanup *cleanup_tuple;
1440 struct cleanup *cleanup_list_data;
1441 struct value_print_options opts;
1443 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1444 ui_out_field_core_addr (uiout, "addr", gdbarch, addr + row_byte);
1445 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr +
1447 cleanup_list_data = make_cleanup_ui_out_list_begin_end (uiout, "data");
1448 get_formatted_print_options (&opts, word_format);
1449 for (col = 0, col_byte = row_byte;
1451 col++, col_byte += word_size)
1453 if (col_byte + word_size > nr_bytes)
1455 ui_out_field_string (uiout, NULL, "N/A");
1459 ui_file_rewind (stream);
1460 print_scalar_formatted (mbuf + col_byte, word_type, &opts,
1461 word_asize, stream);
1462 ui_out_field_stream (uiout, NULL, stream);
1465 do_cleanups (cleanup_list_data);
1470 ui_file_rewind (stream);
1471 for (byte = row_byte;
1472 byte < row_byte + word_size * nr_cols; byte++)
1474 if (byte >= nr_bytes)
1475 fputc_unfiltered ('X', stream);
1476 else if (mbuf[byte] < 32 || mbuf[byte] > 126)
1477 fputc_unfiltered (aschar, stream);
1479 fputc_unfiltered (mbuf[byte], stream);
1481 ui_out_field_stream (uiout, "ascii", stream);
1483 do_cleanups (cleanup_tuple);
1485 do_cleanups (cleanup_stream);
1487 do_cleanups (cleanups);
1491 mi_cmd_data_read_memory_bytes (char *command, char **argv, int argc)
1493 struct gdbarch *gdbarch = get_current_arch ();
1494 struct ui_out *uiout = current_uiout;
1495 struct cleanup *cleanups;
1498 memory_read_result_s *read_result;
1500 VEC(memory_read_result_s) *result;
1508 static const struct mi_opt opts[] =
1510 {"o", OFFSET_OPT, 1},
1516 int opt = mi_getopt ("-data-read-memory-bytes", argc, argv, opts,
1520 switch ((enum opt) opt)
1523 offset = atol (oarg);
1531 error (_("Usage: [ -o OFFSET ] ADDR LENGTH."));
1533 addr = parse_and_eval_address (argv[0]) + offset;
1534 length = atol (argv[1]);
1536 result = read_memory_robust (current_target.beneath, addr, length);
1538 cleanups = make_cleanup (free_memory_read_result_vector, result);
1540 if (VEC_length (memory_read_result_s, result) == 0)
1541 error (_("Unable to read memory."));
1543 make_cleanup_ui_out_list_begin_end (uiout, "memory");
1545 VEC_iterate (memory_read_result_s, result, ix, read_result);
1548 struct cleanup *t = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1552 ui_out_field_core_addr (uiout, "begin", gdbarch, read_result->begin);
1553 ui_out_field_core_addr (uiout, "offset", gdbarch, read_result->begin
1555 ui_out_field_core_addr (uiout, "end", gdbarch, read_result->end);
1557 data = xmalloc ((read_result->end - read_result->begin) * 2 + 1);
1559 for (i = 0, p = data;
1560 i < (read_result->end - read_result->begin);
1563 sprintf (p, "%02x", read_result->data[i]);
1565 ui_out_field_string (uiout, "contents", data);
1569 do_cleanups (cleanups);
1572 /* Implementation of the -data-write_memory command.
1574 COLUMN_OFFSET: optional argument. Must be preceded by '-o'. The
1575 offset from the beginning of the memory grid row where the cell to
1577 ADDR: start address of the row in the memory grid where the memory
1578 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
1579 the location to write to.
1580 FORMAT: a char indicating format for the ``word''. See
1582 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
1583 VALUE: value to be written into the memory address.
1585 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1590 mi_cmd_data_write_memory (char *command, char **argv, int argc)
1592 struct gdbarch *gdbarch = get_current_arch ();
1593 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1596 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1597 enough when using a compiler other than GCC. */
1600 struct cleanup *old_chain;
1608 static const struct mi_opt opts[] =
1610 {"o", OFFSET_OPT, 1},
1616 int opt = mi_getopt ("-data-write-memory", argc, argv, opts,
1621 switch ((enum opt) opt)
1624 offset = atol (oarg);
1632 error (_("-data-write-memory: Usage: "
1633 "[-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE."));
1635 /* Extract all the arguments. */
1636 /* Start address of the memory dump. */
1637 addr = parse_and_eval_address (argv[0]);
1638 /* The size of the memory word. */
1639 word_size = atol (argv[2]);
1641 /* Calculate the real address of the write destination. */
1642 addr += (offset * word_size);
1644 /* Get the value as a number. */
1645 value = parse_and_eval_address (argv[3]);
1646 /* Get the value into an array. */
1647 buffer = xmalloc (word_size);
1648 old_chain = make_cleanup (xfree, buffer);
1649 store_signed_integer (buffer, word_size, byte_order, value);
1650 /* Write it down to memory. */
1651 write_memory_with_notification (addr, buffer, word_size);
1652 /* Free the buffer. */
1653 do_cleanups (old_chain);
1656 /* Implementation of the -data-write-memory-bytes command.
1659 DATA: string of bytes to write at that address
1660 COUNT: number of bytes to be filled (decimal integer). */
1663 mi_cmd_data_write_memory_bytes (char *command, char **argv, int argc)
1669 size_t len, i, steps, remainder;
1671 struct cleanup *back_to;
1673 if (argc != 2 && argc != 3)
1674 error (_("Usage: ADDR DATA [COUNT]."));
1676 addr = parse_and_eval_address (argv[0]);
1678 if (strlen (cdata) % 2)
1679 error (_("Hex-encoded '%s' must have an even number of characters."),
1682 len = strlen (cdata)/2;
1684 count = strtoul (argv[2], NULL, 10);
1688 databuf = xmalloc (len * sizeof (gdb_byte));
1689 back_to = make_cleanup (xfree, databuf);
1691 for (i = 0; i < len; ++i)
1694 if (sscanf (cdata + i * 2, "%02x", &x) != 1)
1695 error (_("Invalid argument"));
1696 databuf[i] = (gdb_byte) x;
1701 /* Pattern is made of less bytes than count:
1702 repeat pattern to fill memory. */
1703 data = xmalloc (count);
1704 make_cleanup (xfree, data);
1706 steps = count / len;
1707 remainder = count % len;
1708 for (j = 0; j < steps; j++)
1709 memcpy (data + j * len, databuf, len);
1712 memcpy (data + steps * len, databuf, remainder);
1716 /* Pattern is longer than or equal to count:
1717 just copy len bytes. */
1721 write_memory_with_notification (addr, data, count);
1723 do_cleanups (back_to);
1727 mi_cmd_enable_timings (char *command, char **argv, int argc)
1733 if (strcmp (argv[0], "yes") == 0)
1735 else if (strcmp (argv[0], "no") == 0)
1746 error (_("-enable-timings: Usage: %s {yes|no}"), command);
1750 mi_cmd_list_features (char *command, char **argv, int argc)
1754 struct cleanup *cleanup = NULL;
1755 struct ui_out *uiout = current_uiout;
1757 cleanup = make_cleanup_ui_out_list_begin_end (uiout, "features");
1758 ui_out_field_string (uiout, NULL, "frozen-varobjs");
1759 ui_out_field_string (uiout, NULL, "pending-breakpoints");
1760 ui_out_field_string (uiout, NULL, "thread-info");
1761 ui_out_field_string (uiout, NULL, "data-read-memory-bytes");
1762 ui_out_field_string (uiout, NULL, "breakpoint-notifications");
1763 ui_out_field_string (uiout, NULL, "ada-task-info");
1766 if (gdb_python_initialized)
1767 ui_out_field_string (uiout, NULL, "python");
1770 do_cleanups (cleanup);
1774 error (_("-list-features should be passed no arguments"));
1778 mi_cmd_list_target_features (char *command, char **argv, int argc)
1782 struct cleanup *cleanup = NULL;
1783 struct ui_out *uiout = current_uiout;
1785 cleanup = make_cleanup_ui_out_list_begin_end (uiout, "features");
1786 if (target_can_async_p ())
1787 ui_out_field_string (uiout, NULL, "async");
1788 if (target_can_execute_reverse)
1789 ui_out_field_string (uiout, NULL, "reverse");
1791 do_cleanups (cleanup);
1795 error (_("-list-target-features should be passed no arguments"));
1799 mi_cmd_add_inferior (char *command, char **argv, int argc)
1801 struct inferior *inf;
1804 error (_("-add-inferior should be passed no arguments"));
1806 inf = add_inferior_with_spaces ();
1808 ui_out_field_fmt (current_uiout, "inferior", "i%d", inf->num);
1811 /* Callback used to find the first inferior other than the current
1815 get_other_inferior (struct inferior *inf, void *arg)
1817 if (inf == current_inferior ())
1824 mi_cmd_remove_inferior (char *command, char **argv, int argc)
1827 struct inferior *inf;
1830 error (_("-remove-inferior should be passed a single argument"));
1832 if (sscanf (argv[0], "i%d", &id) != 1)
1833 error (_("the thread group id is syntactically invalid"));
1835 inf = find_inferior_id (id);
1837 error (_("the specified thread group does not exist"));
1840 error (_("cannot remove an active inferior"));
1842 if (inf == current_inferior ())
1844 struct thread_info *tp = 0;
1845 struct inferior *new_inferior
1846 = iterate_over_inferiors (get_other_inferior, NULL);
1848 if (new_inferior == NULL)
1849 error (_("Cannot remove last inferior"));
1851 set_current_inferior (new_inferior);
1852 if (new_inferior->pid != 0)
1853 tp = any_thread_of_process (new_inferior->pid);
1854 switch_to_thread (tp ? tp->ptid : null_ptid);
1855 set_current_program_space (new_inferior->pspace);
1858 delete_inferior_1 (inf, 1 /* silent */);
1863 /* Execute a command within a safe environment.
1864 Return <0 for error; >=0 for ok.
1866 args->action will tell mi_execute_command what action
1867 to perfrom after the given command has executed (display/suppress
1868 prompt, display error). */
1871 captured_mi_execute_command (struct ui_out *uiout, struct mi_parse *context)
1873 struct cleanup *cleanup;
1876 current_command_ts = context->cmd_start;
1878 current_token = xstrdup (context->token);
1879 cleanup = make_cleanup (free_current_contents, ¤t_token);
1881 running_result_record_printed = 0;
1883 switch (context->op)
1886 /* A MI command was read from the input stream. */
1888 /* FIXME: gdb_???? */
1889 fprintf_unfiltered (raw_stdout, " token=`%s' command=`%s' args=`%s'\n",
1890 context->token, context->command, context->args);
1892 mi_cmd_execute (context);
1894 /* Print the result if there were no errors.
1896 Remember that on the way out of executing a command, you have
1897 to directly use the mi_interp's uiout, since the command
1898 could have reset the interpreter, in which case the current
1899 uiout will most likely crash in the mi_out_* routines. */
1900 if (!running_result_record_printed)
1902 fputs_unfiltered (context->token, raw_stdout);
1903 /* There's no particularly good reason why target-connect results
1904 in not ^done. Should kill ^connected for MI3. */
1905 fputs_unfiltered (strcmp (context->command, "target-select") == 0
1906 ? "^connected" : "^done", raw_stdout);
1907 mi_out_put (uiout, raw_stdout);
1908 mi_out_rewind (uiout);
1909 mi_print_timing_maybe ();
1910 fputs_unfiltered ("\n", raw_stdout);
1913 /* The command does not want anything to be printed. In that
1914 case, the command probably should not have written anything
1915 to uiout, but in case it has written something, discard it. */
1916 mi_out_rewind (uiout);
1923 /* A CLI command was read from the input stream. */
1924 /* This "feature" will be removed as soon as we have a
1925 complete set of mi commands. */
1926 /* Echo the command on the console. */
1927 fprintf_unfiltered (gdb_stdlog, "%s\n", context->command);
1928 /* Call the "console" interpreter. */
1929 argv[0] = "console";
1930 argv[1] = context->command;
1931 mi_cmd_interpreter_exec ("-interpreter-exec", argv, 2);
1933 /* If we changed interpreters, DON'T print out anything. */
1934 if (current_interp_named_p (INTERP_MI)
1935 || current_interp_named_p (INTERP_MI1)
1936 || current_interp_named_p (INTERP_MI2)
1937 || current_interp_named_p (INTERP_MI3))
1939 if (!running_result_record_printed)
1941 fputs_unfiltered (context->token, raw_stdout);
1942 fputs_unfiltered ("^done", raw_stdout);
1943 mi_out_put (uiout, raw_stdout);
1944 mi_out_rewind (uiout);
1945 mi_print_timing_maybe ();
1946 fputs_unfiltered ("\n", raw_stdout);
1949 mi_out_rewind (uiout);
1955 do_cleanups (cleanup);
1958 /* Print a gdb exception to the MI output stream. */
1961 mi_print_exception (const char *token, struct gdb_exception exception)
1963 fputs_unfiltered (token, raw_stdout);
1964 fputs_unfiltered ("^error,msg=\"", raw_stdout);
1965 if (exception.message == NULL)
1966 fputs_unfiltered ("unknown error", raw_stdout);
1968 fputstr_unfiltered (exception.message, '"', raw_stdout);
1969 fputs_unfiltered ("\"\n", raw_stdout);
1973 mi_execute_command (const char *cmd, int from_tty)
1976 struct mi_parse *command = NULL;
1977 volatile struct gdb_exception exception;
1979 /* This is to handle EOF (^D). We just quit gdb. */
1980 /* FIXME: we should call some API function here. */
1982 quit_force (NULL, from_tty);
1984 target_log_command (cmd);
1986 TRY_CATCH (exception, RETURN_MASK_ALL)
1988 command = mi_parse (cmd, &token);
1990 if (exception.reason < 0)
1992 mi_print_exception (token, exception);
1997 volatile struct gdb_exception result;
1998 ptid_t previous_ptid = inferior_ptid;
2000 command->token = token;
2004 command->cmd_start = (struct mi_timestamp *)
2005 xmalloc (sizeof (struct mi_timestamp));
2006 timestamp (command->cmd_start);
2009 TRY_CATCH (result, RETURN_MASK_ALL)
2011 captured_mi_execute_command (current_uiout, command);
2013 if (result.reason < 0)
2015 /* The command execution failed and error() was called
2017 mi_print_exception (command->token, result);
2018 mi_out_rewind (current_uiout);
2021 bpstat_do_actions ();
2023 if (/* The notifications are only output when the top-level
2024 interpreter (specified on the command line) is MI. */
2025 ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ()))
2026 /* Don't try report anything if there are no threads --
2027 the program is dead. */
2028 && thread_count () != 0
2029 /* -thread-select explicitly changes thread. If frontend uses that
2030 internally, we don't want to emit =thread-selected, since
2031 =thread-selected is supposed to indicate user's intentions. */
2032 && strcmp (command->command, "thread-select") != 0)
2034 struct mi_interp *mi = top_level_interpreter_data ();
2035 int report_change = 0;
2037 if (command->thread == -1)
2039 report_change = (!ptid_equal (previous_ptid, null_ptid)
2040 && !ptid_equal (inferior_ptid, previous_ptid)
2041 && !ptid_equal (inferior_ptid, null_ptid));
2043 else if (!ptid_equal (inferior_ptid, null_ptid))
2045 struct thread_info *ti = inferior_thread ();
2047 report_change = (ti->num != command->thread);
2052 struct thread_info *ti = inferior_thread ();
2054 target_terminal_ours ();
2055 fprintf_unfiltered (mi->event_channel,
2056 "thread-selected,id=\"%d\"",
2058 gdb_flush (mi->event_channel);
2062 mi_parse_free (command);
2067 mi_cmd_execute (struct mi_parse *parse)
2069 struct cleanup *cleanup;
2071 cleanup = prepare_execute_command ();
2073 if (parse->all && parse->thread_group != -1)
2074 error (_("Cannot specify --thread-group together with --all"));
2076 if (parse->all && parse->thread != -1)
2077 error (_("Cannot specify --thread together with --all"));
2079 if (parse->thread_group != -1 && parse->thread != -1)
2080 error (_("Cannot specify --thread together with --thread-group"));
2082 if (parse->frame != -1 && parse->thread == -1)
2083 error (_("Cannot specify --frame without --thread"));
2085 if (parse->thread_group != -1)
2087 struct inferior *inf = find_inferior_id (parse->thread_group);
2088 struct thread_info *tp = 0;
2091 error (_("Invalid thread group for the --thread-group option"));
2093 set_current_inferior (inf);
2094 /* This behaviour means that if --thread-group option identifies
2095 an inferior with multiple threads, then a random one will be
2096 picked. This is not a problem -- frontend should always
2097 provide --thread if it wishes to operate on a specific
2100 tp = any_live_thread_of_process (inf->pid);
2101 switch_to_thread (tp ? tp->ptid : null_ptid);
2102 set_current_program_space (inf->pspace);
2105 if (parse->thread != -1)
2107 struct thread_info *tp = find_thread_id (parse->thread);
2110 error (_("Invalid thread id: %d"), parse->thread);
2112 if (is_exited (tp->ptid))
2113 error (_("Thread id: %d has terminated"), parse->thread);
2115 switch_to_thread (tp->ptid);
2118 if (parse->frame != -1)
2120 struct frame_info *fid;
2121 int frame = parse->frame;
2123 fid = find_relative_frame (get_current_frame (), &frame);
2125 /* find_relative_frame was successful */
2128 error (_("Invalid frame id: %d"), frame);
2131 current_context = parse;
2133 if (parse->cmd->suppress_notification != NULL)
2135 make_cleanup_restore_integer (parse->cmd->suppress_notification);
2136 *parse->cmd->suppress_notification = 1;
2139 if (parse->cmd->argv_func != NULL)
2141 parse->cmd->argv_func (parse->command, parse->argv, parse->argc);
2143 else if (parse->cmd->cli.cmd != 0)
2145 /* FIXME: DELETE THIS. */
2146 /* The operation is still implemented by a cli command. */
2147 /* Must be a synchronous one. */
2148 mi_execute_cli_command (parse->cmd->cli.cmd, parse->cmd->cli.args_p,
2153 /* FIXME: DELETE THIS. */
2154 struct ui_file *stb;
2156 stb = mem_fileopen ();
2158 fputs_unfiltered ("Undefined mi command: ", stb);
2159 fputstr_unfiltered (parse->command, '"', stb);
2160 fputs_unfiltered (" (missing implementation)", stb);
2162 make_cleanup_ui_file_delete (stb);
2165 do_cleanups (cleanup);
2168 /* FIXME: This is just a hack so we can get some extra commands going.
2169 We don't want to channel things through the CLI, but call libgdb directly.
2170 Use only for synchronous commands. */
2173 mi_execute_cli_command (const char *cmd, int args_p, const char *args)
2177 struct cleanup *old_cleanups;
2181 run = xstrprintf ("%s %s", cmd, args);
2183 run = xstrdup (cmd);
2185 /* FIXME: gdb_???? */
2186 fprintf_unfiltered (gdb_stdout, "cli=%s run=%s\n",
2188 old_cleanups = make_cleanup (xfree, run);
2189 execute_command (run, 0 /* from_tty */ );
2190 do_cleanups (old_cleanups);
2196 mi_execute_async_cli_command (char *cli_command, char **argv, int argc)
2198 struct cleanup *old_cleanups;
2201 if (target_can_async_p ())
2202 run = xstrprintf ("%s %s&", cli_command, argc ? *argv : "");
2204 run = xstrprintf ("%s %s", cli_command, argc ? *argv : "");
2205 old_cleanups = make_cleanup (xfree, run);
2207 execute_command (run, 0 /* from_tty */ );
2209 /* Do this before doing any printing. It would appear that some
2210 print code leaves garbage around in the buffer. */
2211 do_cleanups (old_cleanups);
2215 mi_load_progress (const char *section_name,
2216 unsigned long sent_so_far,
2217 unsigned long total_section,
2218 unsigned long total_sent,
2219 unsigned long grand_total)
2221 struct timeval time_now, delta, update_threshold;
2222 static struct timeval last_update;
2223 static char *previous_sect_name = NULL;
2225 struct ui_out *saved_uiout;
2226 struct ui_out *uiout;
2228 /* This function is called through deprecated_show_load_progress
2229 which means uiout may not be correct. Fix it for the duration
2230 of this function. */
2231 saved_uiout = current_uiout;
2233 if (current_interp_named_p (INTERP_MI)
2234 || current_interp_named_p (INTERP_MI2))
2235 current_uiout = mi_out_new (2);
2236 else if (current_interp_named_p (INTERP_MI1))
2237 current_uiout = mi_out_new (1);
2238 else if (current_interp_named_p (INTERP_MI3))
2239 current_uiout = mi_out_new (3);
2243 uiout = current_uiout;
2245 update_threshold.tv_sec = 0;
2246 update_threshold.tv_usec = 500000;
2247 gettimeofday (&time_now, NULL);
2249 delta.tv_usec = time_now.tv_usec - last_update.tv_usec;
2250 delta.tv_sec = time_now.tv_sec - last_update.tv_sec;
2252 if (delta.tv_usec < 0)
2255 delta.tv_usec += 1000000L;
2258 new_section = (previous_sect_name ?
2259 strcmp (previous_sect_name, section_name) : 1);
2262 struct cleanup *cleanup_tuple;
2264 xfree (previous_sect_name);
2265 previous_sect_name = xstrdup (section_name);
2268 fputs_unfiltered (current_token, raw_stdout);
2269 fputs_unfiltered ("+download", raw_stdout);
2270 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
2271 ui_out_field_string (uiout, "section", section_name);
2272 ui_out_field_int (uiout, "section-size", total_section);
2273 ui_out_field_int (uiout, "total-size", grand_total);
2274 do_cleanups (cleanup_tuple);
2275 mi_out_put (uiout, raw_stdout);
2276 fputs_unfiltered ("\n", raw_stdout);
2277 gdb_flush (raw_stdout);
2280 if (delta.tv_sec >= update_threshold.tv_sec &&
2281 delta.tv_usec >= update_threshold.tv_usec)
2283 struct cleanup *cleanup_tuple;
2285 last_update.tv_sec = time_now.tv_sec;
2286 last_update.tv_usec = time_now.tv_usec;
2288 fputs_unfiltered (current_token, raw_stdout);
2289 fputs_unfiltered ("+download", raw_stdout);
2290 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
2291 ui_out_field_string (uiout, "section", section_name);
2292 ui_out_field_int (uiout, "section-sent", sent_so_far);
2293 ui_out_field_int (uiout, "section-size", total_section);
2294 ui_out_field_int (uiout, "total-sent", total_sent);
2295 ui_out_field_int (uiout, "total-size", grand_total);
2296 do_cleanups (cleanup_tuple);
2297 mi_out_put (uiout, raw_stdout);
2298 fputs_unfiltered ("\n", raw_stdout);
2299 gdb_flush (raw_stdout);
2303 current_uiout = saved_uiout;
2307 timestamp (struct mi_timestamp *tv)
2309 gettimeofday (&tv->wallclock, NULL);
2310 #ifdef HAVE_GETRUSAGE
2311 getrusage (RUSAGE_SELF, &rusage);
2312 tv->utime.tv_sec = rusage.ru_utime.tv_sec;
2313 tv->utime.tv_usec = rusage.ru_utime.tv_usec;
2314 tv->stime.tv_sec = rusage.ru_stime.tv_sec;
2315 tv->stime.tv_usec = rusage.ru_stime.tv_usec;
2318 long usec = get_run_time ();
2320 tv->utime.tv_sec = usec/1000000L;
2321 tv->utime.tv_usec = usec - 1000000L*tv->utime.tv_sec;
2322 tv->stime.tv_sec = 0;
2323 tv->stime.tv_usec = 0;
2329 print_diff_now (struct mi_timestamp *start)
2331 struct mi_timestamp now;
2334 print_diff (start, &now);
2338 mi_print_timing_maybe (void)
2340 /* If the command is -enable-timing then do_timings may be true
2341 whilst current_command_ts is not initialized. */
2342 if (do_timings && current_command_ts)
2343 print_diff_now (current_command_ts);
2347 timeval_diff (struct timeval start, struct timeval end)
2349 return ((end.tv_sec - start.tv_sec) * 1000000L)
2350 + (end.tv_usec - start.tv_usec);
2354 print_diff (struct mi_timestamp *start, struct mi_timestamp *end)
2358 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
2359 timeval_diff (start->wallclock, end->wallclock) / 1000000.0,
2360 timeval_diff (start->utime, end->utime) / 1000000.0,
2361 timeval_diff (start->stime, end->stime) / 1000000.0);
2365 mi_cmd_trace_define_variable (char *command, char **argv, int argc)
2367 struct expression *expr;
2368 LONGEST initval = 0;
2369 struct trace_state_variable *tsv;
2372 if (argc != 1 && argc != 2)
2373 error (_("Usage: -trace-define-variable VARIABLE [VALUE]"));
2377 error (_("Name of trace variable should start with '$'"));
2379 validate_trace_state_variable_name (name);
2381 tsv = find_trace_state_variable (name);
2383 tsv = create_trace_state_variable (name);
2386 initval = value_as_long (parse_and_eval (argv[1]));
2388 tsv->initial_value = initval;
2392 mi_cmd_trace_list_variables (char *command, char **argv, int argc)
2395 error (_("-trace-list-variables: no arguments allowed"));
2397 tvariables_info_1 ();
2401 mi_cmd_trace_find (char *command, char **argv, int argc)
2406 error (_("trace selection mode is required"));
2410 if (strcmp (mode, "none") == 0)
2412 tfind_1 (tfind_number, -1, 0, 0, 0);
2416 if (current_trace_status ()->running)
2417 error (_("May not look at trace frames while trace is running."));
2419 if (strcmp (mode, "frame-number") == 0)
2422 error (_("frame number is required"));
2423 tfind_1 (tfind_number, atoi (argv[1]), 0, 0, 0);
2425 else if (strcmp (mode, "tracepoint-number") == 0)
2428 error (_("tracepoint number is required"));
2429 tfind_1 (tfind_tp, atoi (argv[1]), 0, 0, 0);
2431 else if (strcmp (mode, "pc") == 0)
2434 error (_("PC is required"));
2435 tfind_1 (tfind_pc, 0, parse_and_eval_address (argv[1]), 0, 0);
2437 else if (strcmp (mode, "pc-inside-range") == 0)
2440 error (_("Start and end PC are required"));
2441 tfind_1 (tfind_range, 0, parse_and_eval_address (argv[1]),
2442 parse_and_eval_address (argv[2]), 0);
2444 else if (strcmp (mode, "pc-outside-range") == 0)
2447 error (_("Start and end PC are required"));
2448 tfind_1 (tfind_outside, 0, parse_and_eval_address (argv[1]),
2449 parse_and_eval_address (argv[2]), 0);
2451 else if (strcmp (mode, "line") == 0)
2453 struct symtabs_and_lines sals;
2454 struct symtab_and_line sal;
2455 static CORE_ADDR start_pc, end_pc;
2456 struct cleanup *back_to;
2459 error (_("Line is required"));
2461 sals = decode_line_with_current_source (argv[1],
2462 DECODE_LINE_FUNFIRSTLINE);
2463 back_to = make_cleanup (xfree, sals.sals);
2467 if (sal.symtab == 0)
2468 error (_("Could not find the specified line"));
2470 if (sal.line > 0 && find_line_pc_range (sal, &start_pc, &end_pc))
2471 tfind_1 (tfind_range, 0, start_pc, end_pc - 1, 0);
2473 error (_("Could not find the specified line"));
2475 do_cleanups (back_to);
2478 error (_("Invalid mode '%s'"), mode);
2480 if (has_stack_frames () || get_traceframe_number () >= 0)
2481 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
2485 mi_cmd_trace_save (char *command, char **argv, int argc)
2487 int target_saves = 0;
2488 int generate_ctf = 0;
2495 TARGET_SAVE_OPT, CTF_OPT
2497 static const struct mi_opt opts[] =
2499 {"r", TARGET_SAVE_OPT, 0},
2500 {"ctf", CTF_OPT, 0},
2506 int opt = mi_getopt ("-trace-save", argc, argv, opts,
2511 switch ((enum opt) opt)
2513 case TARGET_SAVE_OPT:
2521 filename = argv[oind];
2524 trace_save_ctf (filename, target_saves);
2526 trace_save_tfile (filename, target_saves);
2530 mi_cmd_trace_start (char *command, char **argv, int argc)
2532 start_tracing (NULL);
2536 mi_cmd_trace_status (char *command, char **argv, int argc)
2538 trace_status_mi (0);
2542 mi_cmd_trace_stop (char *command, char **argv, int argc)
2544 stop_tracing (NULL);
2545 trace_status_mi (1);
2548 /* Implement the "-ada-task-info" command. */
2551 mi_cmd_ada_task_info (char *command, char **argv, int argc)
2553 if (argc != 0 && argc != 1)
2554 error (_("Invalid MI command"));
2556 print_ada_task_info (current_uiout, argv[0], current_inferior ());