3 Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010
4 Free Software Foundation, Inc.
6 Contributed by Cygnus Solutions (a Red Hat company).
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 /* Work in progress. */
26 #include "arch-utils.h"
29 #include "gdb_string.h"
30 #include "exceptions.h"
32 #include "gdbthread.h"
35 #include "mi-getopt.h"
36 #include "mi-console.h"
40 #include "event-loop.h"
41 #include "event-top.h"
42 #include "gdbcore.h" /* For write_memory(). */
48 #include "mi-common.h"
53 #include "splay-tree.h"
54 #include "tracepoint.h"
59 #if defined HAVE_SYS_RESOURCE_H
60 #include <sys/resource.h>
73 struct ui_file *raw_stdout;
75 /* This is used to pass the current command timestamp
76 down to continuation routines. */
77 static struct mi_timestamp *current_command_ts;
79 static int do_timings = 0;
82 /* Few commands would like to know if options like --thread-group
83 were explicitly specified. This variable keeps the current
84 parsed command including all option, and make it possible. */
85 static struct mi_parse *current_context;
87 int running_result_record_printed = 1;
89 /* Flag indicating that the target has proceeded since the last
90 command was issued. */
93 extern void _initialize_mi_main (void);
94 static void mi_cmd_execute (struct mi_parse *parse);
96 static void mi_execute_cli_command (const char *cmd, int args_p,
98 static void mi_execute_async_cli_command (char *cli_command,
99 char **argv, int argc);
100 static int register_changed_p (int regnum, struct regcache *,
102 static void get_register (struct frame_info *, int regnum, int format);
104 /* Command implementations. FIXME: Is this libgdb? No. This is the MI
105 layer that calls libgdb. Any operation used in the below should be
108 static void timestamp (struct mi_timestamp *tv);
110 static void print_diff_now (struct mi_timestamp *start);
111 static void print_diff (struct mi_timestamp *start, struct mi_timestamp *end);
114 mi_cmd_gdb_exit (char *command, char **argv, int argc)
116 /* We have to print everything right here because we never return. */
118 fputs_unfiltered (current_token, raw_stdout);
119 fputs_unfiltered ("^exit\n", raw_stdout);
120 mi_out_put (uiout, raw_stdout);
121 gdb_flush (raw_stdout);
122 /* FIXME: The function called is not yet a formal libgdb function. */
123 quit_force (NULL, FROM_TTY);
127 mi_cmd_exec_next (char *command, char **argv, int argc)
129 /* FIXME: Should call a libgdb function, not a cli wrapper. */
130 if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
131 mi_execute_async_cli_command ("reverse-next", argv + 1, argc - 1);
133 mi_execute_async_cli_command ("next", argv, argc);
137 mi_cmd_exec_next_instruction (char *command, char **argv, int argc)
139 /* FIXME: Should call a libgdb function, not a cli wrapper. */
140 if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
141 mi_execute_async_cli_command ("reverse-nexti", argv + 1, argc - 1);
143 mi_execute_async_cli_command ("nexti", argv, argc);
147 mi_cmd_exec_step (char *command, char **argv, int argc)
149 /* FIXME: Should call a libgdb function, not a cli wrapper. */
150 if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
151 mi_execute_async_cli_command ("reverse-step", argv + 1, argc - 1);
153 mi_execute_async_cli_command ("step", argv, argc);
157 mi_cmd_exec_step_instruction (char *command, char **argv, int argc)
159 /* FIXME: Should call a libgdb function, not a cli wrapper. */
160 if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
161 mi_execute_async_cli_command ("reverse-stepi", argv + 1, argc - 1);
163 mi_execute_async_cli_command ("stepi", argv, argc);
167 mi_cmd_exec_finish (char *command, char **argv, int argc)
169 /* FIXME: Should call a libgdb function, not a cli wrapper. */
170 if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
171 mi_execute_async_cli_command ("reverse-finish", argv + 1, argc - 1);
173 mi_execute_async_cli_command ("finish", argv, argc);
177 mi_cmd_exec_return (char *command, char **argv, int argc)
179 /* This command doesn't really execute the target, it just pops the
180 specified number of frames. */
182 /* Call return_command with from_tty argument equal to 0 so as to
183 avoid being queried. */
184 return_command (*argv, 0);
186 /* Call return_command with from_tty argument equal to 0 so as to
187 avoid being queried. */
188 return_command (NULL, 0);
190 /* Because we have called return_command with from_tty = 0, we need
191 to print the frame here. */
192 print_stack_frame (get_selected_frame (NULL), 1, LOC_AND_ADDRESS);
196 mi_cmd_exec_jump (char *args, char **argv, int argc)
198 /* FIXME: Should call a libgdb function, not a cli wrapper. */
199 mi_execute_async_cli_command ("jump", argv, argc);
203 proceed_thread (struct thread_info *thread, int pid)
205 if (!is_stopped (thread->ptid))
208 if (pid != 0 && PIDGET (thread->ptid) != pid)
211 switch_to_thread (thread->ptid);
212 clear_proceed_status ();
213 proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 0);
218 proceed_thread_callback (struct thread_info *thread, void *arg)
220 int pid = *(int *)arg;
222 proceed_thread (thread, pid);
227 exec_continue (char **argv, int argc)
231 /* In non-stop mode, 'resume' always resumes a single thread. Therefore,
232 to resume all threads of the current inferior, or all threads in all
233 inferiors, we need to iterate over threads.
235 See comment on infcmd.c:proceed_thread_callback for rationale. */
236 if (current_context->all || current_context->thread_group != -1)
239 struct cleanup *back_to = make_cleanup_restore_current_thread ();
241 if (!current_context->all)
243 struct inferior *inf = find_inferior_id (current_context->thread_group);
246 iterate_over_threads (proceed_thread_callback, &pid);
247 do_cleanups (back_to);
256 struct cleanup *back_to = make_cleanup_restore_integer (&sched_multi);
258 if (current_context->all)
265 /* In all-stop mode, -exec-continue traditionally resumed either
266 all threads, or one thread, depending on the 'scheduler-locking'
267 variable. Let's continue to do the same. */
270 do_cleanups (back_to);
275 exec_direction_forward (void *notused)
277 execution_direction = EXEC_FORWARD;
281 exec_reverse_continue (char **argv, int argc)
283 enum exec_direction_kind dir = execution_direction;
284 struct cleanup *old_chain;
286 if (dir == EXEC_ERROR)
287 error (_("Target %s does not support this command."), target_shortname);
289 if (dir == EXEC_REVERSE)
290 error (_("Already in reverse mode."));
292 if (!target_can_execute_reverse)
293 error (_("Target %s does not support this command."), target_shortname);
295 old_chain = make_cleanup (exec_direction_forward, NULL);
296 execution_direction = EXEC_REVERSE;
297 exec_continue (argv, argc);
298 do_cleanups (old_chain);
302 mi_cmd_exec_continue (char *command, char **argv, int argc)
304 if (argc > 0 && strcmp (argv[0], "--reverse") == 0)
305 exec_reverse_continue (argv + 1, argc - 1);
307 exec_continue (argv, argc);
311 interrupt_thread_callback (struct thread_info *thread, void *arg)
313 int pid = *(int *)arg;
315 if (!is_running (thread->ptid))
318 if (PIDGET (thread->ptid) != pid)
321 target_stop (thread->ptid);
325 /* Interrupt the execution of the target. Note how we must play around
326 with the token variables, in order to display the current token in
327 the result of the interrupt command, and the previous execution
328 token when the target finally stops. See comments in
331 mi_cmd_exec_interrupt (char *command, char **argv, int argc)
333 /* In all-stop mode, everything stops, so we don't need to try
334 anything specific. */
337 interrupt_target_1 (0);
341 if (current_context->all)
343 /* This will interrupt all threads in all inferiors. */
344 interrupt_target_1 (1);
346 else if (current_context->thread_group != -1)
348 struct inferior *inf = find_inferior_id (current_context->thread_group);
350 iterate_over_threads (interrupt_thread_callback, &inf->pid);
354 /* Interrupt just the current thread -- either explicitly
355 specified via --thread or whatever was current before
356 MI command was sent. */
357 interrupt_target_1 (0);
362 run_one_inferior (struct inferior *inf, void *arg)
366 if (inf->pid != ptid_get_pid (inferior_ptid))
368 struct thread_info *tp;
370 tp = any_thread_of_process (inf->pid);
372 error (_("Inferior has no threads."));
374 switch_to_thread (tp->ptid);
379 set_current_inferior (inf);
380 switch_to_thread (null_ptid);
381 set_current_program_space (inf->pspace);
383 mi_execute_cli_command ("run", target_can_async_p (),
384 target_can_async_p () ? "&" : NULL);
389 mi_cmd_exec_run (char *command, char **argv, int argc)
391 if (current_context->all)
393 struct cleanup *back_to = save_current_space_and_thread ();
395 iterate_over_inferiors (run_one_inferior, NULL);
396 do_cleanups (back_to);
400 mi_execute_cli_command ("run", target_can_async_p (),
401 target_can_async_p () ? "&" : NULL);
407 find_thread_of_process (struct thread_info *ti, void *p)
411 if (PIDGET (ti->ptid) == pid && !is_exited (ti->ptid))
418 mi_cmd_target_detach (char *command, char **argv, int argc)
420 if (argc != 0 && argc != 1)
421 error ("Usage: -target-detach [pid | thread-group]");
425 struct thread_info *tp;
429 /* First see if we are dealing with a thread-group id. */
432 struct inferior *inf;
433 int id = strtoul (argv[0] + 1, &end, 0);
436 error (_("Invalid syntax of thread-group id '%s'"), argv[0]);
438 inf = find_inferior_id (id);
440 error (_("Non-existent thread-group id '%d'"), id);
446 /* We must be dealing with a pid. */
447 pid = strtol (argv[0], &end, 10);
450 error (_("Invalid identifier '%s'"), argv[0]);
453 /* Pick any thread in the desired process. Current
454 target_detach detaches from the parent of inferior_ptid. */
455 tp = iterate_over_threads (find_thread_of_process, &pid);
457 error (_("Thread group is empty"));
459 switch_to_thread (tp->ptid);
462 detach_command (NULL, 0);
466 mi_cmd_thread_select (char *command, char **argv, int argc)
469 char *mi_error_message;
472 error ("mi_cmd_thread_select: USAGE: threadnum.");
474 rc = gdb_thread_select (uiout, argv[0], &mi_error_message);
476 if (rc == GDB_RC_FAIL)
478 make_cleanup (xfree, mi_error_message);
479 error ("%s", mi_error_message);
484 mi_cmd_thread_list_ids (char *command, char **argv, int argc)
487 char *mi_error_message;
490 error ("mi_cmd_thread_list_ids: No arguments required.");
492 rc = gdb_list_thread_ids (uiout, &mi_error_message);
494 if (rc == GDB_RC_FAIL)
496 make_cleanup (xfree, mi_error_message);
497 error ("%s", mi_error_message);
502 mi_cmd_thread_info (char *command, char **argv, int argc)
506 if (argc != 0 && argc != 1)
507 error ("Invalid MI command");
510 thread = atoi (argv[0]);
512 print_thread_info (uiout, thread, -1);
515 struct collect_cores_data
523 collect_cores (struct thread_info *ti, void *xdata)
525 struct collect_cores_data *data = xdata;
527 if (ptid_get_pid (ti->ptid) == data->pid)
529 int core = target_core_of_thread (ti->ptid);
532 VEC_safe_push (int, data->cores, core);
539 unique (int *b, int *e)
549 struct print_one_inferior_data
552 VEC (int) *inferiors;
556 print_one_inferior (struct inferior *inferior, void *xdata)
558 struct print_one_inferior_data *top_data = xdata;
560 if (VEC_empty (int, top_data->inferiors)
561 || bsearch (&(inferior->pid), VEC_address (int, top_data->inferiors),
562 VEC_length (int, top_data->inferiors), sizeof (int),
563 compare_positive_ints))
565 struct collect_cores_data data;
566 struct cleanup *back_to
567 = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
569 ui_out_field_fmt (uiout, "id", "i%d", inferior->num);
570 ui_out_field_string (uiout, "type", "process");
571 if (inferior->pid != 0)
572 ui_out_field_int (uiout, "pid", inferior->pid);
574 if (inferior->pspace->ebfd)
576 ui_out_field_string (uiout, "executable",
577 bfd_get_filename (inferior->pspace->ebfd));
581 if (inferior->pid != 0)
583 data.pid = inferior->pid;
584 iterate_over_threads (collect_cores, &data);
587 if (!VEC_empty (int, data.cores))
590 struct cleanup *back_to_2 =
591 make_cleanup_ui_out_list_begin_end (uiout, "cores");
593 qsort (VEC_address (int, data.cores),
594 VEC_length (int, data.cores), sizeof (int),
595 compare_positive_ints);
597 b = VEC_address (int, data.cores);
598 e = b + VEC_length (int, data.cores);
602 ui_out_field_int (uiout, NULL, *b);
604 do_cleanups (back_to_2);
607 if (top_data->recurse)
608 print_thread_info (uiout, -1, inferior->pid);
610 do_cleanups (back_to);
616 /* Output a field named 'cores' with a list as the value. The elements of
617 the list are obtained by splitting 'cores' on comma. */
620 output_cores (struct ui_out *uiout, const char *field_name, const char *xcores)
622 struct cleanup *back_to = make_cleanup_ui_out_list_begin_end (uiout,
624 char *cores = xstrdup (xcores);
627 make_cleanup (xfree, cores);
629 for (p = strtok (p, ","); p; p = strtok (NULL, ","))
630 ui_out_field_string (uiout, NULL, p);
632 do_cleanups (back_to);
636 free_vector_of_ints (void *xvector)
638 VEC (int) **vector = xvector;
640 VEC_free (int, *vector);
644 do_nothing (splay_tree_key k)
649 free_vector_of_osdata_items (splay_tree_value xvalue)
651 VEC (osdata_item_s) *value = (VEC (osdata_item_s) *) xvalue;
653 /* We don't free the items itself, it will be done separately. */
654 VEC_free (osdata_item_s, value);
658 splay_tree_int_comparator (splay_tree_key xa, splay_tree_key xb)
667 free_splay_tree (void *xt)
670 splay_tree_delete (t);
674 list_available_thread_groups (VEC (int) *ids, int recurse)
677 struct osdata_item *item;
680 /* This keeps a map from integer (pid) to VEC (struct osdata_item *)*
681 The vector contains information about all threads for the given pid.
682 This is assigned an initial value to avoid "may be used uninitialized"
684 splay_tree tree = NULL;
686 /* get_osdata will throw if it cannot return data. */
687 data = get_osdata ("processes");
688 make_cleanup_osdata_free (data);
692 struct osdata *threads = get_osdata ("threads");
694 make_cleanup_osdata_free (threads);
695 tree = splay_tree_new (splay_tree_int_comparator,
697 free_vector_of_osdata_items);
698 make_cleanup (free_splay_tree, tree);
701 VEC_iterate (osdata_item_s, threads->items,
705 const char *pid = get_osdata_column (item, "pid");
706 int pid_i = strtoul (pid, NULL, 0);
707 VEC (osdata_item_s) *vec = 0;
709 splay_tree_node n = splay_tree_lookup (tree, pid_i);
712 VEC_safe_push (osdata_item_s, vec, item);
713 splay_tree_insert (tree, pid_i, (splay_tree_value)vec);
717 vec = (VEC (osdata_item_s) *) n->value;
718 VEC_safe_push (osdata_item_s, vec, item);
719 n->value = (splay_tree_value) vec;
724 make_cleanup_ui_out_list_begin_end (uiout, "groups");
727 VEC_iterate (osdata_item_s, data->items,
731 struct cleanup *back_to;
733 const char *pid = get_osdata_column (item, "pid");
734 const char *cmd = get_osdata_column (item, "command");
735 const char *user = get_osdata_column (item, "user");
736 const char *cores = get_osdata_column (item, "cores");
738 int pid_i = strtoul (pid, NULL, 0);
740 /* At present, the target will return all available processes
741 and if information about specific ones was required, we filter
742 undesired processes here. */
743 if (ids && bsearch (&pid_i, VEC_address (int, ids),
744 VEC_length (int, ids),
745 sizeof (int), compare_positive_ints) == NULL)
749 back_to = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
751 ui_out_field_fmt (uiout, "id", "%s", pid);
752 ui_out_field_string (uiout, "type", "process");
754 ui_out_field_string (uiout, "description", cmd);
756 ui_out_field_string (uiout, "user", user);
758 output_cores (uiout, "cores", cores);
762 splay_tree_node n = splay_tree_lookup (tree, pid_i);
765 VEC (osdata_item_s) *children = (VEC (osdata_item_s) *) n->value;
766 struct osdata_item *child;
769 make_cleanup_ui_out_list_begin_end (uiout, "threads");
772 VEC_iterate (osdata_item_s, children, ix_child, child);
775 struct cleanup *back_to_2 =
776 make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
777 const char *tid = get_osdata_column (child, "tid");
778 const char *tcore = get_osdata_column (child, "core");
780 ui_out_field_string (uiout, "id", tid);
782 ui_out_field_string (uiout, "core", tcore);
784 do_cleanups (back_to_2);
789 do_cleanups (back_to);
794 mi_cmd_list_thread_groups (char *command, char **argv, int argc)
796 struct cleanup *back_to;
803 AVAILABLE_OPT, RECURSE_OPT
805 static struct mi_opt opts[] =
807 {"-available", AVAILABLE_OPT, 0},
808 {"-recurse", RECURSE_OPT, 1},
817 int opt = mi_getopt ("-list-thread-groups", argc, argv, opts,
822 switch ((enum opt) opt)
828 if (strcmp (optarg, "0") == 0)
830 else if (strcmp (optarg, "1") == 0)
833 error ("only '0' and '1' are valid values for the '--recurse' option");
838 for (; optind < argc; ++optind)
843 if (*(argv[optind]) != 'i')
844 error ("invalid syntax of group id '%s'", argv[optind]);
846 inf = strtoul (argv[optind] + 1, &end, 0);
849 error ("invalid syntax of group id '%s'", argv[optind]);
850 VEC_safe_push (int, ids, inf);
852 if (VEC_length (int, ids) > 1)
853 qsort (VEC_address (int, ids),
854 VEC_length (int, ids),
855 sizeof (int), compare_positive_ints);
857 back_to = make_cleanup (free_vector_of_ints, &ids);
861 list_available_thread_groups (ids, recurse);
863 else if (VEC_length (int, ids) == 1)
865 /* Local thread groups, single id. */
866 int id = *VEC_address (int, ids);
867 struct inferior *inf = find_inferior_id (id);
870 error ("Non-existent thread group id '%d'", id);
872 print_thread_info (uiout, -1, inf->pid);
876 struct print_one_inferior_data data;
878 data.recurse = recurse;
879 data.inferiors = ids;
881 /* Local thread groups. Either no explicit ids -- and we
882 print everything, or several explicit ids. In both cases,
883 we print more than one group, and have to use 'groups'
884 as the top-level element. */
885 make_cleanup_ui_out_list_begin_end (uiout, "groups");
886 update_thread_list ();
887 iterate_over_inferiors (print_one_inferior, &data);
890 do_cleanups (back_to);
894 mi_cmd_data_list_register_names (char *command, char **argv, int argc)
896 struct gdbarch *gdbarch;
899 struct cleanup *cleanup;
901 /* Note that the test for a valid register must include checking the
902 gdbarch_register_name because gdbarch_num_regs may be allocated for
903 the union of the register sets within a family of related processors.
904 In this case, some entries of gdbarch_register_name will change depending
905 upon the particular processor being debugged. */
907 gdbarch = get_current_arch ();
908 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
910 cleanup = make_cleanup_ui_out_list_begin_end (uiout, "register-names");
912 if (argc == 0) /* No args, just do all the regs. */
918 if (gdbarch_register_name (gdbarch, regnum) == NULL
919 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
920 ui_out_field_string (uiout, NULL, "");
922 ui_out_field_string (uiout, NULL,
923 gdbarch_register_name (gdbarch, regnum));
927 /* Else, list of register #s, just do listed regs. */
928 for (i = 0; i < argc; i++)
930 regnum = atoi (argv[i]);
931 if (regnum < 0 || regnum >= numregs)
932 error ("bad register number");
934 if (gdbarch_register_name (gdbarch, regnum) == NULL
935 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
936 ui_out_field_string (uiout, NULL, "");
938 ui_out_field_string (uiout, NULL,
939 gdbarch_register_name (gdbarch, regnum));
941 do_cleanups (cleanup);
945 mi_cmd_data_list_changed_registers (char *command, char **argv, int argc)
947 static struct regcache *this_regs = NULL;
948 struct regcache *prev_regs;
949 struct gdbarch *gdbarch;
950 int regnum, numregs, changed;
952 struct cleanup *cleanup;
954 /* The last time we visited this function, the current frame's register
955 contents were saved in THIS_REGS. Move THIS_REGS over to PREV_REGS,
956 and refresh THIS_REGS with the now-current register contents. */
958 prev_regs = this_regs;
959 this_regs = frame_save_as_regcache (get_selected_frame (NULL));
960 cleanup = make_cleanup_regcache_xfree (prev_regs);
962 /* Note that the test for a valid register must include checking the
963 gdbarch_register_name because gdbarch_num_regs may be allocated for
964 the union of the register sets within a family of related processors.
965 In this case, some entries of gdbarch_register_name will change depending
966 upon the particular processor being debugged. */
968 gdbarch = get_regcache_arch (this_regs);
969 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
971 make_cleanup_ui_out_list_begin_end (uiout, "changed-registers");
973 if (argc == 0) /* No args, just do all the regs. */
979 if (gdbarch_register_name (gdbarch, regnum) == NULL
980 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
982 changed = register_changed_p (regnum, prev_regs, this_regs);
984 error ("mi_cmd_data_list_changed_registers: Unable to read register contents.");
986 ui_out_field_int (uiout, NULL, regnum);
990 /* Else, list of register #s, just do listed regs. */
991 for (i = 0; i < argc; i++)
993 regnum = atoi (argv[i]);
997 && gdbarch_register_name (gdbarch, regnum) != NULL
998 && *gdbarch_register_name (gdbarch, regnum) != '\000')
1000 changed = register_changed_p (regnum, prev_regs, this_regs);
1002 error ("mi_cmd_data_list_register_change: Unable to read register contents.");
1004 ui_out_field_int (uiout, NULL, regnum);
1007 error ("bad register number");
1009 do_cleanups (cleanup);
1013 register_changed_p (int regnum, struct regcache *prev_regs,
1014 struct regcache *this_regs)
1016 struct gdbarch *gdbarch = get_regcache_arch (this_regs);
1017 gdb_byte prev_buffer[MAX_REGISTER_SIZE];
1018 gdb_byte this_buffer[MAX_REGISTER_SIZE];
1020 /* Registers not valid in this frame return count as unchanged. */
1021 if (!regcache_valid_p (this_regs, regnum))
1024 /* First time through or after gdbarch change consider all registers as
1025 changed. Same for registers not valid in the previous frame. */
1026 if (!prev_regs || get_regcache_arch (prev_regs) != gdbarch
1027 || !regcache_valid_p (prev_regs, regnum))
1030 /* Get register contents and compare. */
1031 regcache_cooked_read (prev_regs, regnum, prev_buffer);
1032 regcache_cooked_read (this_regs, regnum, this_buffer);
1034 return memcmp (prev_buffer, this_buffer,
1035 register_size (gdbarch, regnum)) != 0;
1038 /* Return a list of register number and value pairs. The valid
1039 arguments expected are: a letter indicating the format in which to
1040 display the registers contents. This can be one of: x (hexadecimal), d
1041 (decimal), N (natural), t (binary), o (octal), r (raw). After the
1042 format argumetn there can be a sequence of numbers, indicating which
1043 registers to fetch the content of. If the format is the only argument,
1044 a list of all the registers with their values is returned. */
1046 mi_cmd_data_list_register_values (char *command, char **argv, int argc)
1048 struct frame_info *frame;
1049 struct gdbarch *gdbarch;
1050 int regnum, numregs, format;
1052 struct cleanup *list_cleanup, *tuple_cleanup;
1054 /* Note that the test for a valid register must include checking the
1055 gdbarch_register_name because gdbarch_num_regs may be allocated for
1056 the union of the register sets within a family of related processors.
1057 In this case, some entries of gdbarch_register_name will change depending
1058 upon the particular processor being debugged. */
1061 error ("mi_cmd_data_list_register_values: Usage: -data-list-register-values <format> [<regnum1>...<regnumN>]");
1063 format = (int) argv[0][0];
1065 frame = get_selected_frame (NULL);
1066 gdbarch = get_frame_arch (frame);
1067 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
1069 list_cleanup = make_cleanup_ui_out_list_begin_end (uiout, "register-values");
1071 if (argc == 1) /* No args, beside the format: do all the regs. */
1077 if (gdbarch_register_name (gdbarch, regnum) == NULL
1078 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
1080 tuple_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1081 ui_out_field_int (uiout, "number", regnum);
1082 get_register (frame, regnum, format);
1083 do_cleanups (tuple_cleanup);
1087 /* Else, list of register #s, just do listed regs. */
1088 for (i = 1; i < argc; i++)
1090 regnum = atoi (argv[i]);
1094 && gdbarch_register_name (gdbarch, regnum) != NULL
1095 && *gdbarch_register_name (gdbarch, regnum) != '\000')
1097 tuple_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1098 ui_out_field_int (uiout, "number", regnum);
1099 get_register (frame, regnum, format);
1100 do_cleanups (tuple_cleanup);
1103 error ("bad register number");
1105 do_cleanups (list_cleanup);
1108 /* Output one register's contents in the desired format. */
1110 get_register (struct frame_info *frame, int regnum, int format)
1112 struct gdbarch *gdbarch = get_frame_arch (frame);
1113 gdb_byte buffer[MAX_REGISTER_SIZE];
1117 enum lval_type lval;
1118 static struct ui_stream *stb = NULL;
1120 stb = ui_out_stream_new (uiout);
1125 frame_register (frame, regnum, &optim, &lval, &addr, &realnum, buffer);
1128 error ("Optimized out");
1133 char *ptr, buf[1024];
1137 for (j = 0; j < register_size (gdbarch, regnum); j++)
1139 int idx = gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG ?
1140 j : register_size (gdbarch, regnum) - 1 - j;
1142 sprintf (ptr, "%02x", (unsigned char) buffer[idx]);
1145 ui_out_field_string (uiout, "value", buf);
1146 /*fputs_filtered (buf, gdb_stdout); */
1150 struct value_print_options opts;
1152 get_formatted_print_options (&opts, format);
1154 val_print (register_type (gdbarch, regnum), buffer, 0, 0,
1155 stb->stream, 0, NULL, &opts, current_language);
1156 ui_out_field_stream (uiout, "value", stb);
1157 ui_out_stream_delete (stb);
1161 /* Write given values into registers. The registers and values are
1162 given as pairs. The corresponding MI command is
1163 -data-write-register-values <format> [<regnum1> <value1>...<regnumN> <valueN>]*/
1165 mi_cmd_data_write_register_values (char *command, char **argv, int argc)
1167 struct regcache *regcache;
1168 struct gdbarch *gdbarch;
1172 /* Note that the test for a valid register must include checking the
1173 gdbarch_register_name because gdbarch_num_regs may be allocated for
1174 the union of the register sets within a family of related processors.
1175 In this case, some entries of gdbarch_register_name will change depending
1176 upon the particular processor being debugged. */
1178 regcache = get_current_regcache ();
1179 gdbarch = get_regcache_arch (regcache);
1180 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
1183 error ("mi_cmd_data_write_register_values: Usage: -data-write-register-values <format> [<regnum1> <value1>...<regnumN> <valueN>]");
1185 format = (int) argv[0][0];
1187 if (!target_has_registers)
1188 error ("mi_cmd_data_write_register_values: No registers.");
1191 error ("mi_cmd_data_write_register_values: No regs and values specified.");
1194 error ("mi_cmd_data_write_register_values: Regs and vals are not in pairs.");
1196 for (i = 1; i < argc; i = i + 2)
1198 int regnum = atoi (argv[i]);
1200 if (regnum >= 0 && regnum < numregs
1201 && gdbarch_register_name (gdbarch, regnum)
1202 && *gdbarch_register_name (gdbarch, regnum))
1206 /* Get the value as a number. */
1207 value = parse_and_eval_address (argv[i + 1]);
1209 /* Write it down. */
1210 regcache_cooked_write_signed (regcache, regnum, value);
1213 error ("bad register number");
1217 /* Evaluate the value of the argument. The argument is an
1218 expression. If the expression contains spaces it needs to be
1219 included in double quotes. */
1221 mi_cmd_data_evaluate_expression (char *command, char **argv, int argc)
1223 struct expression *expr;
1224 struct cleanup *old_chain = NULL;
1226 struct ui_stream *stb = NULL;
1227 struct value_print_options opts;
1229 stb = ui_out_stream_new (uiout);
1233 ui_out_stream_delete (stb);
1234 error ("mi_cmd_data_evaluate_expression: Usage: -data-evaluate-expression expression");
1237 expr = parse_expression (argv[0]);
1239 old_chain = make_cleanup (free_current_contents, &expr);
1241 val = evaluate_expression (expr);
1243 /* Print the result of the expression evaluation. */
1244 get_user_print_options (&opts);
1246 common_val_print (val, stb->stream, 0, &opts, current_language);
1248 ui_out_field_stream (uiout, "value", stb);
1249 ui_out_stream_delete (stb);
1251 do_cleanups (old_chain);
1254 /* DATA-MEMORY-READ:
1256 ADDR: start address of data to be dumped.
1257 WORD-FORMAT: a char indicating format for the ``word''. See
1259 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
1260 NR_ROW: Number of rows.
1261 NR_COL: The number of colums (words per row).
1262 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
1263 ASCHAR for unprintable characters.
1265 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
1266 displayes them. Returns:
1268 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
1271 The number of bytes read is SIZE*ROW*COL. */
1274 mi_cmd_data_read_memory (char *command, char **argv, int argc)
1276 struct gdbarch *gdbarch = get_current_arch ();
1277 struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
1283 struct type *word_type;
1296 static struct mi_opt opts[] =
1298 {"o", OFFSET_OPT, 1},
1304 int opt = mi_getopt ("mi_cmd_data_read_memory", argc, argv, opts,
1309 switch ((enum opt) opt)
1312 offset = atol (optarg);
1319 if (argc < 5 || argc > 6)
1320 error ("mi_cmd_data_read_memory: Usage: ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR].");
1322 /* Extract all the arguments. */
1324 /* Start address of the memory dump. */
1325 addr = parse_and_eval_address (argv[0]) + offset;
1326 /* The format character to use when displaying a memory word. See
1327 the ``x'' command. */
1328 word_format = argv[1][0];
1329 /* The size of the memory word. */
1330 word_size = atol (argv[2]);
1334 word_type = builtin_type (gdbarch)->builtin_int8;
1338 word_type = builtin_type (gdbarch)->builtin_int16;
1342 word_type = builtin_type (gdbarch)->builtin_int32;
1346 word_type = builtin_type (gdbarch)->builtin_int64;
1350 word_type = builtin_type (gdbarch)->builtin_int8;
1353 /* The number of rows. */
1354 nr_rows = atol (argv[3]);
1356 error ("mi_cmd_data_read_memory: invalid number of rows.");
1358 /* Number of bytes per row. */
1359 nr_cols = atol (argv[4]);
1361 error ("mi_cmd_data_read_memory: invalid number of columns.");
1363 /* The un-printable character when printing ascii. */
1369 /* Create a buffer and read it in. */
1370 total_bytes = word_size * nr_rows * nr_cols;
1371 mbuf = xcalloc (total_bytes, 1);
1372 make_cleanup (xfree, mbuf);
1374 /* Dispatch memory reads to the topmost target, not the flattened
1376 nr_bytes = target_read (current_target.beneath,
1377 TARGET_OBJECT_MEMORY, NULL, mbuf,
1380 error ("Unable to read memory.");
1382 /* Output the header information. */
1383 ui_out_field_core_addr (uiout, "addr", gdbarch, addr);
1384 ui_out_field_int (uiout, "nr-bytes", nr_bytes);
1385 ui_out_field_int (uiout, "total-bytes", total_bytes);
1386 ui_out_field_core_addr (uiout, "next-row",
1387 gdbarch, addr + word_size * nr_cols);
1388 ui_out_field_core_addr (uiout, "prev-row",
1389 gdbarch, addr - word_size * nr_cols);
1390 ui_out_field_core_addr (uiout, "next-page", gdbarch, addr + total_bytes);
1391 ui_out_field_core_addr (uiout, "prev-page", gdbarch, addr - total_bytes);
1393 /* Build the result as a two dimentional table. */
1395 struct ui_stream *stream = ui_out_stream_new (uiout);
1396 struct cleanup *cleanup_list_memory;
1400 cleanup_list_memory = make_cleanup_ui_out_list_begin_end (uiout, "memory");
1401 for (row = 0, row_byte = 0;
1403 row++, row_byte += nr_cols * word_size)
1407 struct cleanup *cleanup_tuple;
1408 struct cleanup *cleanup_list_data;
1409 struct value_print_options opts;
1411 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1412 ui_out_field_core_addr (uiout, "addr", gdbarch, addr + row_byte);
1413 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr + row_byte); */
1414 cleanup_list_data = make_cleanup_ui_out_list_begin_end (uiout, "data");
1415 get_formatted_print_options (&opts, word_format);
1416 for (col = 0, col_byte = row_byte;
1418 col++, col_byte += word_size)
1420 if (col_byte + word_size > nr_bytes)
1422 ui_out_field_string (uiout, NULL, "N/A");
1426 ui_file_rewind (stream->stream);
1427 print_scalar_formatted (mbuf + col_byte, word_type, &opts,
1428 word_asize, stream->stream);
1429 ui_out_field_stream (uiout, NULL, stream);
1432 do_cleanups (cleanup_list_data);
1437 ui_file_rewind (stream->stream);
1438 for (byte = row_byte; byte < row_byte + word_size * nr_cols; byte++)
1440 if (byte >= nr_bytes)
1442 fputc_unfiltered ('X', stream->stream);
1444 else if (mbuf[byte] < 32 || mbuf[byte] > 126)
1446 fputc_unfiltered (aschar, stream->stream);
1449 fputc_unfiltered (mbuf[byte], stream->stream);
1451 ui_out_field_stream (uiout, "ascii", stream);
1453 do_cleanups (cleanup_tuple);
1455 ui_out_stream_delete (stream);
1456 do_cleanups (cleanup_list_memory);
1458 do_cleanups (cleanups);
1462 mi_cmd_data_read_memory_bytes (char *command, char **argv, int argc)
1464 struct gdbarch *gdbarch = get_current_arch ();
1465 struct cleanup *cleanups;
1468 memory_read_result_s *read_result;
1470 VEC(memory_read_result_s) *result;
1478 static struct mi_opt opts[] =
1480 {"o", OFFSET_OPT, 1},
1486 int opt = mi_getopt ("mi_cmd_data_read_memory_bytes", argc, argv, opts,
1490 switch ((enum opt) opt)
1493 offset = atol (optarg);
1501 error ("Usage: [ -o OFFSET ] ADDR LENGTH.");
1503 addr = parse_and_eval_address (argv[0]) + offset;
1504 length = atol (argv[1]);
1506 result = read_memory_robust (current_target.beneath, addr, length);
1508 cleanups = make_cleanup (free_memory_read_result_vector, result);
1510 if (VEC_length (memory_read_result_s, result) == 0)
1511 error ("Unable to read memory.");
1513 make_cleanup_ui_out_list_begin_end (uiout, "memory");
1515 VEC_iterate (memory_read_result_s, result, ix, read_result);
1518 struct cleanup *t = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1522 ui_out_field_core_addr (uiout, "begin", gdbarch, read_result->begin);
1523 ui_out_field_core_addr (uiout, "offset", gdbarch, read_result->begin
1525 ui_out_field_core_addr (uiout, "end", gdbarch, read_result->end);
1527 data = xmalloc ((read_result->end - read_result->begin) * 2 + 1);
1529 for (i = 0, p = data;
1530 i < (read_result->end - read_result->begin);
1533 sprintf (p, "%02x", read_result->data[i]);
1535 ui_out_field_string (uiout, "contents", data);
1539 do_cleanups (cleanups);
1543 /* DATA-MEMORY-WRITE:
1545 COLUMN_OFFSET: optional argument. Must be preceeded by '-o'. The
1546 offset from the beginning of the memory grid row where the cell to
1548 ADDR: start address of the row in the memory grid where the memory
1549 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
1550 the location to write to.
1551 FORMAT: a char indicating format for the ``word''. See
1553 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
1554 VALUE: value to be written into the memory address.
1556 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1560 mi_cmd_data_write_memory (char *command, char **argv, int argc)
1562 struct gdbarch *gdbarch = get_current_arch ();
1563 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1567 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1568 enough when using a compiler other than GCC. */
1571 struct cleanup *old_chain;
1579 static struct mi_opt opts[] =
1581 {"o", OFFSET_OPT, 1},
1587 int opt = mi_getopt ("mi_cmd_data_write_memory", argc, argv, opts,
1592 switch ((enum opt) opt)
1595 offset = atol (optarg);
1603 error ("mi_cmd_data_write_memory: Usage: [-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE.");
1605 /* Extract all the arguments. */
1606 /* Start address of the memory dump. */
1607 addr = parse_and_eval_address (argv[0]);
1608 /* The format character to use when displaying a memory word. See
1609 the ``x'' command. */
1610 word_format = argv[1][0];
1611 /* The size of the memory word. */
1612 word_size = atol (argv[2]);
1614 /* Calculate the real address of the write destination. */
1615 addr += (offset * word_size);
1617 /* Get the value as a number. */
1618 value = parse_and_eval_address (argv[3]);
1619 /* Get the value into an array. */
1620 buffer = xmalloc (word_size);
1621 old_chain = make_cleanup (xfree, buffer);
1622 store_signed_integer (buffer, word_size, byte_order, value);
1623 /* Write it down to memory. */
1624 write_memory (addr, buffer, word_size);
1625 /* Free the buffer. */
1626 do_cleanups (old_chain);
1629 /* DATA-MEMORY-WRITE-RAW:
1632 DATA: string of bytes to write at that address. */
1634 mi_cmd_data_write_memory_bytes (char *command, char **argv, int argc)
1640 struct cleanup *back_to;
1643 error ("Usage: ADDR DATA.");
1645 addr = parse_and_eval_address (argv[0]);
1647 len = strlen (cdata)/2;
1649 data = xmalloc (len);
1650 back_to = make_cleanup (xfree, data);
1652 for (i = 0; i < len; ++i)
1655 sscanf (cdata + i * 2, "%02x", &x);
1656 data[i] = (gdb_byte)x;
1659 r = target_write_memory (addr, data, len);
1661 error (_("Could not write memory"));
1663 do_cleanups (back_to);
1668 mi_cmd_enable_timings (char *command, char **argv, int argc)
1674 if (strcmp (argv[0], "yes") == 0)
1676 else if (strcmp (argv[0], "no") == 0)
1687 error ("mi_cmd_enable_timings: Usage: %s {yes|no}", command);
1691 mi_cmd_list_features (char *command, char **argv, int argc)
1695 struct cleanup *cleanup = NULL;
1697 cleanup = make_cleanup_ui_out_list_begin_end (uiout, "features");
1698 ui_out_field_string (uiout, NULL, "frozen-varobjs");
1699 ui_out_field_string (uiout, NULL, "pending-breakpoints");
1700 ui_out_field_string (uiout, NULL, "thread-info");
1701 ui_out_field_string (uiout, NULL, "data-read-memory-bytes");
1704 ui_out_field_string (uiout, NULL, "python");
1707 do_cleanups (cleanup);
1711 error ("-list-features should be passed no arguments");
1715 mi_cmd_list_target_features (char *command, char **argv, int argc)
1719 struct cleanup *cleanup = NULL;
1721 cleanup = make_cleanup_ui_out_list_begin_end (uiout, "features");
1722 if (target_can_async_p ())
1723 ui_out_field_string (uiout, NULL, "async");
1724 if (target_can_execute_reverse)
1725 ui_out_field_string (uiout, NULL, "reverse");
1727 do_cleanups (cleanup);
1731 error ("-list-target-features should be passed no arguments");
1735 mi_cmd_add_inferior (char *command, char **argv, int argc)
1737 struct inferior *inf;
1740 error (_("-add-inferior should be passed no arguments"));
1742 inf = add_inferior_with_spaces ();
1744 ui_out_field_fmt (uiout, "inferior", "i%d", inf->num);
1747 /* Callback used to find the first inferior other than the
1751 get_other_inferior (struct inferior *inf, void *arg)
1753 if (inf == current_inferior ())
1760 mi_cmd_remove_inferior (char *command, char **argv, int argc)
1763 struct inferior *inf;
1766 error ("-remove-inferior should be passed a single argument");
1768 if (sscanf (argv[0], "i%d", &id) != 1)
1769 error ("the thread group id is syntactically invalid");
1771 inf = find_inferior_id (id);
1773 error ("the specified thread group does not exist");
1775 if (inf == current_inferior ())
1777 struct thread_info *tp = 0;
1778 struct inferior *new_inferior
1779 = iterate_over_inferiors (get_other_inferior, NULL);
1781 if (new_inferior == NULL)
1782 error (_("Cannot remove last inferior"));
1784 set_current_inferior (new_inferior);
1785 if (new_inferior->pid != 0)
1786 tp = any_thread_of_process (new_inferior->pid);
1787 switch_to_thread (tp ? tp->ptid : null_ptid);
1788 set_current_program_space (new_inferior->pspace);
1791 delete_inferior_1 (inf, 1 /* silent */);
1796 /* Execute a command within a safe environment.
1797 Return <0 for error; >=0 for ok.
1799 args->action will tell mi_execute_command what action
1800 to perfrom after the given command has executed (display/suppress
1801 prompt, display error). */
1804 captured_mi_execute_command (struct ui_out *uiout, void *data)
1806 struct cleanup *cleanup;
1807 struct mi_parse *context = (struct mi_parse *) data;
1810 current_command_ts = context->cmd_start;
1812 current_token = xstrdup (context->token);
1813 cleanup = make_cleanup (free_current_contents, ¤t_token);
1815 running_result_record_printed = 0;
1817 switch (context->op)
1820 /* A MI command was read from the input stream. */
1822 /* FIXME: gdb_???? */
1823 fprintf_unfiltered (raw_stdout, " token=`%s' command=`%s' args=`%s'\n",
1824 context->token, context->command, context->args);
1827 mi_cmd_execute (context);
1829 /* Print the result if there were no errors.
1831 Remember that on the way out of executing a command, you have
1832 to directly use the mi_interp's uiout, since the command could
1833 have reset the interpreter, in which case the current uiout
1834 will most likely crash in the mi_out_* routines. */
1835 if (!running_result_record_printed)
1837 fputs_unfiltered (context->token, raw_stdout);
1838 /* There's no particularly good reason why target-connect results
1839 in not ^done. Should kill ^connected for MI3. */
1840 fputs_unfiltered (strcmp (context->command, "target-select") == 0
1841 ? "^connected" : "^done", raw_stdout);
1842 mi_out_put (uiout, raw_stdout);
1843 mi_out_rewind (uiout);
1844 mi_print_timing_maybe ();
1845 fputs_unfiltered ("\n", raw_stdout);
1848 /* The command does not want anything to be printed. In that
1849 case, the command probably should not have written anything
1850 to uiout, but in case it has written something, discard it. */
1851 mi_out_rewind (uiout);
1858 /* A CLI command was read from the input stream. */
1859 /* This "feature" will be removed as soon as we have a
1860 complete set of mi commands. */
1861 /* Echo the command on the console. */
1862 fprintf_unfiltered (gdb_stdlog, "%s\n", context->command);
1863 /* Call the "console" interpreter. */
1864 argv[0] = "console";
1865 argv[1] = context->command;
1866 mi_cmd_interpreter_exec ("-interpreter-exec", argv, 2);
1868 /* If we changed interpreters, DON'T print out anything. */
1869 if (current_interp_named_p (INTERP_MI)
1870 || current_interp_named_p (INTERP_MI1)
1871 || current_interp_named_p (INTERP_MI2)
1872 || current_interp_named_p (INTERP_MI3))
1874 if (!running_result_record_printed)
1876 fputs_unfiltered (context->token, raw_stdout);
1877 fputs_unfiltered ("^done", raw_stdout);
1878 mi_out_put (uiout, raw_stdout);
1879 mi_out_rewind (uiout);
1880 mi_print_timing_maybe ();
1881 fputs_unfiltered ("\n", raw_stdout);
1884 mi_out_rewind (uiout);
1891 do_cleanups (cleanup);
1896 /* Print a gdb exception to the MI output stream. */
1899 mi_print_exception (const char *token, struct gdb_exception exception)
1901 fputs_unfiltered (token, raw_stdout);
1902 fputs_unfiltered ("^error,msg=\"", raw_stdout);
1903 if (exception.message == NULL)
1904 fputs_unfiltered ("unknown error", raw_stdout);
1906 fputstr_unfiltered (exception.message, '"', raw_stdout);
1907 fputs_unfiltered ("\"\n", raw_stdout);
1911 mi_execute_command (char *cmd, int from_tty)
1914 struct mi_parse *command = NULL;
1915 volatile struct gdb_exception exception;
1917 /* This is to handle EOF (^D). We just quit gdb. */
1918 /* FIXME: we should call some API function here. */
1920 quit_force (NULL, from_tty);
1922 target_log_command (cmd);
1924 TRY_CATCH (exception, RETURN_MASK_ALL)
1926 command = mi_parse (cmd, &token);
1928 if (exception.reason < 0)
1930 mi_print_exception (token, exception);
1935 struct gdb_exception result;
1936 ptid_t previous_ptid = inferior_ptid;
1938 command->token = token;
1942 command->cmd_start = (struct mi_timestamp *)
1943 xmalloc (sizeof (struct mi_timestamp));
1944 timestamp (command->cmd_start);
1947 result = catch_exception (uiout, captured_mi_execute_command, command,
1949 if (result.reason < 0)
1951 /* The command execution failed and error() was called
1953 mi_print_exception (command->token, result);
1954 mi_out_rewind (uiout);
1957 bpstat_do_actions ();
1959 if (/* The notifications are only output when the top-level
1960 interpreter (specified on the command line) is MI. */
1961 ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ()))
1962 /* Don't try report anything if there are no threads --
1963 the program is dead. */
1964 && thread_count () != 0
1965 /* -thread-select explicitly changes thread. If frontend uses that
1966 internally, we don't want to emit =thread-selected, since
1967 =thread-selected is supposed to indicate user's intentions. */
1968 && strcmp (command->command, "thread-select") != 0)
1970 struct mi_interp *mi = top_level_interpreter_data ();
1971 int report_change = 0;
1973 if (command->thread == -1)
1975 report_change = (!ptid_equal (previous_ptid, null_ptid)
1976 && !ptid_equal (inferior_ptid, previous_ptid)
1977 && !ptid_equal (inferior_ptid, null_ptid));
1979 else if (!ptid_equal (inferior_ptid, null_ptid))
1981 struct thread_info *ti = inferior_thread ();
1983 report_change = (ti->num != command->thread);
1988 struct thread_info *ti = inferior_thread ();
1990 target_terminal_ours ();
1991 fprintf_unfiltered (mi->event_channel,
1992 "thread-selected,id=\"%d\"",
1994 gdb_flush (mi->event_channel);
1998 mi_parse_free (command);
2001 fputs_unfiltered ("(gdb) \n", raw_stdout);
2002 gdb_flush (raw_stdout);
2003 /* Print any buffered hook code. */
2008 mi_cmd_execute (struct mi_parse *parse)
2010 struct cleanup *cleanup;
2012 prepare_execute_command ();
2014 cleanup = make_cleanup (null_cleanup, NULL);
2016 if (parse->all && parse->thread_group != -1)
2017 error (_("Cannot specify --thread-group together with --all"));
2019 if (parse->all && parse->thread != -1)
2020 error (_("Cannot specify --thread together with --all"));
2022 if (parse->thread_group != -1 && parse->thread != -1)
2023 error (_("Cannot specify --thread together with --thread-group"));
2025 if (parse->frame != -1 && parse->thread == -1)
2026 error (_("Cannot specify --frame without --thread"));
2028 if (parse->thread_group != -1)
2030 struct inferior *inf = find_inferior_id (parse->thread_group);
2031 struct thread_info *tp = 0;
2034 error (_("Invalid thread group for the --thread-group option"));
2036 set_current_inferior (inf);
2037 /* This behaviour means that if --thread-group option identifies
2038 an inferior with multiple threads, then a random one will be picked.
2039 This is not a problem -- frontend should always provide --thread if
2040 it wishes to operate on a specific thread. */
2042 tp = any_thread_of_process (inf->pid);
2043 switch_to_thread (tp ? tp->ptid : null_ptid);
2044 set_current_program_space (inf->pspace);
2047 if (parse->thread != -1)
2049 struct thread_info *tp = find_thread_id (parse->thread);
2052 error (_("Invalid thread id: %d"), parse->thread);
2054 if (is_exited (tp->ptid))
2055 error (_("Thread id: %d has terminated"), parse->thread);
2057 switch_to_thread (tp->ptid);
2060 if (parse->frame != -1)
2062 struct frame_info *fid;
2063 int frame = parse->frame;
2065 fid = find_relative_frame (get_current_frame (), &frame);
2067 /* find_relative_frame was successful */
2070 error (_("Invalid frame id: %d"), frame);
2073 current_context = parse;
2075 if (parse->cmd->argv_func != NULL)
2076 parse->cmd->argv_func (parse->command, parse->argv, parse->argc);
2077 else if (parse->cmd->cli.cmd != 0)
2079 /* FIXME: DELETE THIS. */
2080 /* The operation is still implemented by a cli command. */
2081 /* Must be a synchronous one. */
2082 mi_execute_cli_command (parse->cmd->cli.cmd, parse->cmd->cli.args_p,
2087 /* FIXME: DELETE THIS. */
2088 struct ui_file *stb;
2090 stb = mem_fileopen ();
2092 fputs_unfiltered ("Undefined mi command: ", stb);
2093 fputstr_unfiltered (parse->command, '"', stb);
2094 fputs_unfiltered (" (missing implementation)", stb);
2096 make_cleanup_ui_file_delete (stb);
2099 do_cleanups (cleanup);
2102 /* FIXME: This is just a hack so we can get some extra commands going.
2103 We don't want to channel things through the CLI, but call libgdb directly.
2104 Use only for synchronous commands. */
2107 mi_execute_cli_command (const char *cmd, int args_p, const char *args)
2111 struct cleanup *old_cleanups;
2115 run = xstrprintf ("%s %s", cmd, args);
2117 run = xstrdup (cmd);
2119 /* FIXME: gdb_???? */
2120 fprintf_unfiltered (gdb_stdout, "cli=%s run=%s\n",
2122 old_cleanups = make_cleanup (xfree, run);
2123 execute_command ( /*ui */ run, 0 /*from_tty */ );
2124 do_cleanups (old_cleanups);
2130 mi_execute_async_cli_command (char *cli_command, char **argv, int argc)
2132 struct cleanup *old_cleanups;
2135 if (target_can_async_p ())
2136 run = xstrprintf ("%s %s&", cli_command, argc ? *argv : "");
2138 run = xstrprintf ("%s %s", cli_command, argc ? *argv : "");
2139 old_cleanups = make_cleanup (xfree, run);
2141 execute_command ( /*ui */ run, 0 /*from_tty */ );
2143 if (target_can_async_p ())
2145 /* If we're not executing, an exception should have been throw. */
2146 gdb_assert (is_running (inferior_ptid));
2147 do_cleanups (old_cleanups);
2151 /* Do this before doing any printing. It would appear that some
2152 print code leaves garbage around in the buffer. */
2153 do_cleanups (old_cleanups);
2158 mi_load_progress (const char *section_name,
2159 unsigned long sent_so_far,
2160 unsigned long total_section,
2161 unsigned long total_sent,
2162 unsigned long grand_total)
2164 struct timeval time_now, delta, update_threshold;
2165 static struct timeval last_update;
2166 static char *previous_sect_name = NULL;
2168 struct ui_out *saved_uiout;
2170 /* This function is called through deprecated_show_load_progress
2171 which means uiout may not be correct. Fix it for the duration
2172 of this function. */
2173 saved_uiout = uiout;
2175 if (current_interp_named_p (INTERP_MI)
2176 || current_interp_named_p (INTERP_MI2))
2177 uiout = mi_out_new (2);
2178 else if (current_interp_named_p (INTERP_MI1))
2179 uiout = mi_out_new (1);
2180 else if (current_interp_named_p (INTERP_MI3))
2181 uiout = mi_out_new (3);
2185 update_threshold.tv_sec = 0;
2186 update_threshold.tv_usec = 500000;
2187 gettimeofday (&time_now, NULL);
2189 delta.tv_usec = time_now.tv_usec - last_update.tv_usec;
2190 delta.tv_sec = time_now.tv_sec - last_update.tv_sec;
2192 if (delta.tv_usec < 0)
2195 delta.tv_usec += 1000000L;
2198 new_section = (previous_sect_name ?
2199 strcmp (previous_sect_name, section_name) : 1);
2202 struct cleanup *cleanup_tuple;
2204 xfree (previous_sect_name);
2205 previous_sect_name = xstrdup (section_name);
2208 fputs_unfiltered (current_token, raw_stdout);
2209 fputs_unfiltered ("+download", raw_stdout);
2210 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
2211 ui_out_field_string (uiout, "section", section_name);
2212 ui_out_field_int (uiout, "section-size", total_section);
2213 ui_out_field_int (uiout, "total-size", grand_total);
2214 do_cleanups (cleanup_tuple);
2215 mi_out_put (uiout, raw_stdout);
2216 fputs_unfiltered ("\n", raw_stdout);
2217 gdb_flush (raw_stdout);
2220 if (delta.tv_sec >= update_threshold.tv_sec &&
2221 delta.tv_usec >= update_threshold.tv_usec)
2223 struct cleanup *cleanup_tuple;
2225 last_update.tv_sec = time_now.tv_sec;
2226 last_update.tv_usec = time_now.tv_usec;
2228 fputs_unfiltered (current_token, raw_stdout);
2229 fputs_unfiltered ("+download", raw_stdout);
2230 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
2231 ui_out_field_string (uiout, "section", section_name);
2232 ui_out_field_int (uiout, "section-sent", sent_so_far);
2233 ui_out_field_int (uiout, "section-size", total_section);
2234 ui_out_field_int (uiout, "total-sent", total_sent);
2235 ui_out_field_int (uiout, "total-size", grand_total);
2236 do_cleanups (cleanup_tuple);
2237 mi_out_put (uiout, raw_stdout);
2238 fputs_unfiltered ("\n", raw_stdout);
2239 gdb_flush (raw_stdout);
2243 uiout = saved_uiout;
2247 timestamp (struct mi_timestamp *tv)
2249 gettimeofday (&tv->wallclock, NULL);
2250 #ifdef HAVE_GETRUSAGE
2251 getrusage (RUSAGE_SELF, &rusage);
2252 tv->utime.tv_sec = rusage.ru_utime.tv_sec;
2253 tv->utime.tv_usec = rusage.ru_utime.tv_usec;
2254 tv->stime.tv_sec = rusage.ru_stime.tv_sec;
2255 tv->stime.tv_usec = rusage.ru_stime.tv_usec;
2258 long usec = get_run_time ();
2260 tv->utime.tv_sec = usec/1000000L;
2261 tv->utime.tv_usec = usec - 1000000L*tv->utime.tv_sec;
2262 tv->stime.tv_sec = 0;
2263 tv->stime.tv_usec = 0;
2269 print_diff_now (struct mi_timestamp *start)
2271 struct mi_timestamp now;
2274 print_diff (start, &now);
2278 mi_print_timing_maybe (void)
2280 /* If the command is -enable-timing then do_timings may be
2281 true whilst current_command_ts is not initialized. */
2282 if (do_timings && current_command_ts)
2283 print_diff_now (current_command_ts);
2287 timeval_diff (struct timeval start, struct timeval end)
2289 return ((end.tv_sec - start.tv_sec) * 1000000L)
2290 + (end.tv_usec - start.tv_usec);
2294 print_diff (struct mi_timestamp *start, struct mi_timestamp *end)
2298 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
2299 timeval_diff (start->wallclock, end->wallclock) / 1000000.0,
2300 timeval_diff (start->utime, end->utime) / 1000000.0,
2301 timeval_diff (start->stime, end->stime) / 1000000.0);
2305 mi_cmd_trace_define_variable (char *command, char **argv, int argc)
2307 struct expression *expr;
2308 struct cleanup *back_to;
2309 LONGEST initval = 0;
2310 struct trace_state_variable *tsv;
2313 if (argc != 1 && argc != 2)
2314 error (_("Usage: -trace-define-variable VARIABLE [VALUE]"));
2316 expr = parse_expression (argv[0]);
2317 back_to = make_cleanup (xfree, expr);
2319 if (expr->nelts == 3 && expr->elts[0].opcode == OP_INTERNALVAR)
2321 struct internalvar *intvar = expr->elts[1].internalvar;
2324 name = internalvar_name (intvar);
2327 if (!name || *name == '\0')
2328 error (_("Invalid name of trace variable"));
2330 tsv = find_trace_state_variable (name);
2332 tsv = create_trace_state_variable (name);
2335 initval = value_as_long (parse_and_eval (argv[1]));
2337 tsv->initial_value = initval;
2339 do_cleanups (back_to);
2343 mi_cmd_trace_list_variables (char *command, char **argv, int argc)
2346 error (_("-trace-list-variables: no arguments are allowed"));
2348 tvariables_info_1 ();
2352 mi_cmd_trace_find (char *command, char **argv, int argc)
2357 error (_("trace selection mode is required"));
2361 if (strcmp (mode, "none") == 0)
2363 tfind_1 (tfind_number, -1, 0, 0, 0);
2367 if (current_trace_status ()->running)
2368 error (_("May not look at trace frames while trace is running."));
2370 if (strcmp (mode, "frame-number") == 0)
2373 error (_("frame number is required"));
2374 tfind_1 (tfind_number, atoi (argv[1]), 0, 0, 0);
2376 else if (strcmp (mode, "tracepoint-number") == 0)
2379 error (_("tracepoint number is required"));
2380 tfind_1 (tfind_tp, atoi (argv[1]), 0, 0, 0);
2382 else if (strcmp (mode, "pc") == 0)
2385 error (_("PC is required"));
2386 tfind_1 (tfind_pc, 0, parse_and_eval_address (argv[1]), 0, 0);
2388 else if (strcmp (mode, "pc-inside-range") == 0)
2391 error (_("Start and end PC are required"));
2392 tfind_1 (tfind_range, 0, parse_and_eval_address (argv[1]),
2393 parse_and_eval_address (argv[2]), 0);
2395 else if (strcmp (mode, "pc-outside-range") == 0)
2398 error (_("Start and end PC are required"));
2399 tfind_1 (tfind_outside, 0, parse_and_eval_address (argv[1]),
2400 parse_and_eval_address (argv[2]), 0);
2402 else if (strcmp (mode, "line") == 0)
2404 struct symtabs_and_lines sals;
2405 struct symtab_and_line sal;
2406 static CORE_ADDR start_pc, end_pc;
2407 struct cleanup *back_to;
2410 error (_("Line is required"));
2412 sals = decode_line_spec (argv[1], 1);
2413 back_to = make_cleanup (xfree, sals.sals);
2417 if (sal.symtab == 0)
2418 error (_("Could not find the specified line"));
2420 if (sal.line > 0 && find_line_pc_range (sal, &start_pc, &end_pc))
2421 tfind_1 (tfind_range, 0, start_pc, end_pc - 1, 0);
2423 error (_("Could not find the specified line"));
2425 do_cleanups (back_to);
2428 error (_("Invalid mode '%s'"), mode);
2430 if (has_stack_frames () || get_traceframe_number () >= 0)
2432 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
2437 mi_cmd_trace_save (char *command, char **argv, int argc)
2439 int target_saves = 0;
2442 if (argc != 1 && argc != 2)
2443 error (_("Usage: -trace-save [-r] filename"));
2448 if (strcmp (argv[0], "-r") == 0)
2451 error (_("Invalid option: %s"), argv[0]);
2458 trace_save (filename, target_saves);
2463 mi_cmd_trace_start (char *command, char **argv, int argc)
2469 mi_cmd_trace_status (char *command, char **argv, int argc)
2471 trace_status_mi (0);
2475 mi_cmd_trace_stop (char *command, char **argv, int argc)
2478 trace_status_mi (1);