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 [thread-group]");
425 struct thread_info *tp;
427 int pid = strtol (argv[0], &end, 10);
430 error (_("Cannot parse thread group id '%s'"), argv[0]);
432 /* Pick any thread in the desired process. Current
433 target_detach deteches from the parent of inferior_ptid. */
434 tp = iterate_over_threads (find_thread_of_process, &pid);
436 error (_("Thread group is empty"));
438 switch_to_thread (tp->ptid);
441 detach_command (NULL, 0);
445 mi_cmd_thread_select (char *command, char **argv, int argc)
448 char *mi_error_message;
451 error ("mi_cmd_thread_select: USAGE: threadnum.");
453 rc = gdb_thread_select (uiout, argv[0], &mi_error_message);
455 if (rc == GDB_RC_FAIL)
457 make_cleanup (xfree, mi_error_message);
458 error ("%s", mi_error_message);
463 mi_cmd_thread_list_ids (char *command, char **argv, int argc)
466 char *mi_error_message;
469 error ("mi_cmd_thread_list_ids: No arguments required.");
471 rc = gdb_list_thread_ids (uiout, &mi_error_message);
473 if (rc == GDB_RC_FAIL)
475 make_cleanup (xfree, mi_error_message);
476 error ("%s", mi_error_message);
481 mi_cmd_thread_info (char *command, char **argv, int argc)
485 if (argc != 0 && argc != 1)
486 error ("Invalid MI command");
489 thread = atoi (argv[0]);
491 print_thread_info (uiout, thread, -1);
494 struct collect_cores_data
502 collect_cores (struct thread_info *ti, void *xdata)
504 struct collect_cores_data *data = xdata;
506 if (ptid_get_pid (ti->ptid) == data->pid)
508 int core = target_core_of_thread (ti->ptid);
511 VEC_safe_push (int, data->cores, core);
518 unique (int *b, int *e)
528 struct print_one_inferior_data
531 VEC (int) *inferiors;
535 print_one_inferior (struct inferior *inferior, void *xdata)
537 struct print_one_inferior_data *top_data = xdata;
539 if (VEC_empty (int, top_data->inferiors)
540 || bsearch (&(inferior->pid), VEC_address (int, top_data->inferiors),
541 VEC_length (int, top_data->inferiors), sizeof (int),
542 compare_positive_ints))
544 struct collect_cores_data data;
545 struct cleanup *back_to
546 = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
548 ui_out_field_fmt (uiout, "id", "i%d", inferior->num);
549 ui_out_field_string (uiout, "type", "process");
550 if (inferior->pid != 0)
551 ui_out_field_int (uiout, "pid", inferior->pid);
553 if (inferior->pspace->ebfd)
555 ui_out_field_string (uiout, "executable",
556 bfd_get_filename (inferior->pspace->ebfd));
560 if (inferior->pid != 0)
562 data.pid = inferior->pid;
563 iterate_over_threads (collect_cores, &data);
566 if (!VEC_empty (int, data.cores))
569 struct cleanup *back_to_2 =
570 make_cleanup_ui_out_list_begin_end (uiout, "cores");
572 qsort (VEC_address (int, data.cores),
573 VEC_length (int, data.cores), sizeof (int),
574 compare_positive_ints);
576 b = VEC_address (int, data.cores);
577 e = b + VEC_length (int, data.cores);
581 ui_out_field_int (uiout, NULL, *b);
583 do_cleanups (back_to_2);
586 if (top_data->recurse)
587 print_thread_info (uiout, -1, inferior->pid);
589 do_cleanups (back_to);
595 /* Output a field named 'cores' with a list as the value. The elements of
596 the list are obtained by splitting 'cores' on comma. */
599 output_cores (struct ui_out *uiout, const char *field_name, const char *xcores)
601 struct cleanup *back_to = make_cleanup_ui_out_list_begin_end (uiout,
603 char *cores = xstrdup (xcores);
606 make_cleanup (xfree, cores);
608 for (p = strtok (p, ","); p; p = strtok (NULL, ","))
609 ui_out_field_string (uiout, NULL, p);
611 do_cleanups (back_to);
615 free_vector_of_ints (void *xvector)
617 VEC (int) **vector = xvector;
619 VEC_free (int, *vector);
623 do_nothing (splay_tree_key k)
628 free_vector_of_osdata_items (splay_tree_value xvalue)
630 VEC (osdata_item_s) *value = (VEC (osdata_item_s) *) xvalue;
632 /* We don't free the items itself, it will be done separately. */
633 VEC_free (osdata_item_s, value);
637 splay_tree_int_comparator (splay_tree_key xa, splay_tree_key xb)
646 free_splay_tree (void *xt)
649 splay_tree_delete (t);
653 list_available_thread_groups (VEC (int) *ids, int recurse)
656 struct osdata_item *item;
659 /* This keeps a map from integer (pid) to VEC (struct osdata_item *)*
660 The vector contains information about all threads for the given pid.
661 This is assigned an initial value to avoid "may be used uninitialized"
663 splay_tree tree = NULL;
665 /* get_osdata will throw if it cannot return data. */
666 data = get_osdata ("processes");
667 make_cleanup_osdata_free (data);
671 struct osdata *threads = get_osdata ("threads");
673 make_cleanup_osdata_free (threads);
674 tree = splay_tree_new (splay_tree_int_comparator,
676 free_vector_of_osdata_items);
677 make_cleanup (free_splay_tree, tree);
680 VEC_iterate (osdata_item_s, threads->items,
684 const char *pid = get_osdata_column (item, "pid");
685 int pid_i = strtoul (pid, NULL, 0);
686 VEC (osdata_item_s) *vec = 0;
688 splay_tree_node n = splay_tree_lookup (tree, pid_i);
691 VEC_safe_push (osdata_item_s, vec, item);
692 splay_tree_insert (tree, pid_i, (splay_tree_value)vec);
696 vec = (VEC (osdata_item_s) *) n->value;
697 VEC_safe_push (osdata_item_s, vec, item);
698 n->value = (splay_tree_value) vec;
703 make_cleanup_ui_out_list_begin_end (uiout, "groups");
706 VEC_iterate (osdata_item_s, data->items,
710 struct cleanup *back_to;
712 const char *pid = get_osdata_column (item, "pid");
713 const char *cmd = get_osdata_column (item, "command");
714 const char *user = get_osdata_column (item, "user");
715 const char *cores = get_osdata_column (item, "cores");
717 int pid_i = strtoul (pid, NULL, 0);
719 /* At present, the target will return all available processes
720 and if information about specific ones was required, we filter
721 undesired processes here. */
722 if (ids && bsearch (&pid_i, VEC_address (int, ids),
723 VEC_length (int, ids),
724 sizeof (int), compare_positive_ints) == NULL)
728 back_to = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
730 ui_out_field_fmt (uiout, "id", "%s", pid);
731 ui_out_field_string (uiout, "type", "process");
733 ui_out_field_string (uiout, "description", cmd);
735 ui_out_field_string (uiout, "user", user);
737 output_cores (uiout, "cores", cores);
741 splay_tree_node n = splay_tree_lookup (tree, pid_i);
744 VEC (osdata_item_s) *children = (VEC (osdata_item_s) *) n->value;
745 struct osdata_item *child;
748 make_cleanup_ui_out_list_begin_end (uiout, "threads");
751 VEC_iterate (osdata_item_s, children, ix_child, child);
754 struct cleanup *back_to_2 =
755 make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
756 const char *tid = get_osdata_column (child, "tid");
757 const char *tcore = get_osdata_column (child, "core");
759 ui_out_field_string (uiout, "id", tid);
761 ui_out_field_string (uiout, "core", tcore);
763 do_cleanups (back_to_2);
768 do_cleanups (back_to);
773 mi_cmd_list_thread_groups (char *command, char **argv, int argc)
775 struct cleanup *back_to;
782 AVAILABLE_OPT, RECURSE_OPT
784 static struct mi_opt opts[] =
786 {"-available", AVAILABLE_OPT, 0},
787 {"-recurse", RECURSE_OPT, 1},
796 int opt = mi_getopt ("-list-thread-groups", argc, argv, opts,
801 switch ((enum opt) opt)
807 if (strcmp (optarg, "0") == 0)
809 else if (strcmp (optarg, "1") == 0)
812 error ("only '0' and '1' are valid values for the '--recurse' option");
817 for (; optind < argc; ++optind)
822 if (*(argv[optind]) != 'i')
823 error ("invalid syntax of group id '%s'", argv[optind]);
825 inf = strtoul (argv[optind] + 1, &end, 0);
828 error ("invalid syntax of group id '%s'", argv[optind]);
829 VEC_safe_push (int, ids, inf);
831 if (VEC_length (int, ids) > 1)
832 qsort (VEC_address (int, ids),
833 VEC_length (int, ids),
834 sizeof (int), compare_positive_ints);
836 back_to = make_cleanup (free_vector_of_ints, &ids);
840 list_available_thread_groups (ids, recurse);
842 else if (VEC_length (int, ids) == 1)
844 /* Local thread groups, single id. */
845 int id = *VEC_address (int, ids);
846 struct inferior *inf = find_inferior_id (id);
849 error ("Non-existent thread group id '%d'", id);
851 print_thread_info (uiout, -1, inf->pid);
855 struct print_one_inferior_data data;
857 data.recurse = recurse;
858 data.inferiors = ids;
860 /* Local thread groups. Either no explicit ids -- and we
861 print everything, or several explicit ids. In both cases,
862 we print more than one group, and have to use 'groups'
863 as the top-level element. */
864 make_cleanup_ui_out_list_begin_end (uiout, "groups");
865 update_thread_list ();
866 iterate_over_inferiors (print_one_inferior, &data);
869 do_cleanups (back_to);
873 mi_cmd_data_list_register_names (char *command, char **argv, int argc)
875 struct gdbarch *gdbarch;
878 struct cleanup *cleanup;
880 /* Note that the test for a valid register must include checking the
881 gdbarch_register_name because gdbarch_num_regs may be allocated for
882 the union of the register sets within a family of related processors.
883 In this case, some entries of gdbarch_register_name will change depending
884 upon the particular processor being debugged. */
886 gdbarch = get_current_arch ();
887 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
889 cleanup = make_cleanup_ui_out_list_begin_end (uiout, "register-names");
891 if (argc == 0) /* No args, just do all the regs. */
897 if (gdbarch_register_name (gdbarch, regnum) == NULL
898 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
899 ui_out_field_string (uiout, NULL, "");
901 ui_out_field_string (uiout, NULL,
902 gdbarch_register_name (gdbarch, regnum));
906 /* Else, list of register #s, just do listed regs. */
907 for (i = 0; i < argc; i++)
909 regnum = atoi (argv[i]);
910 if (regnum < 0 || regnum >= numregs)
911 error ("bad register number");
913 if (gdbarch_register_name (gdbarch, regnum) == NULL
914 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
915 ui_out_field_string (uiout, NULL, "");
917 ui_out_field_string (uiout, NULL,
918 gdbarch_register_name (gdbarch, regnum));
920 do_cleanups (cleanup);
924 mi_cmd_data_list_changed_registers (char *command, char **argv, int argc)
926 static struct regcache *this_regs = NULL;
927 struct regcache *prev_regs;
928 struct gdbarch *gdbarch;
929 int regnum, numregs, changed;
931 struct cleanup *cleanup;
933 /* The last time we visited this function, the current frame's register
934 contents were saved in THIS_REGS. Move THIS_REGS over to PREV_REGS,
935 and refresh THIS_REGS with the now-current register contents. */
937 prev_regs = this_regs;
938 this_regs = frame_save_as_regcache (get_selected_frame (NULL));
939 cleanup = make_cleanup_regcache_xfree (prev_regs);
941 /* Note that the test for a valid register must include checking the
942 gdbarch_register_name because gdbarch_num_regs may be allocated for
943 the union of the register sets within a family of related processors.
944 In this case, some entries of gdbarch_register_name will change depending
945 upon the particular processor being debugged. */
947 gdbarch = get_regcache_arch (this_regs);
948 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
950 make_cleanup_ui_out_list_begin_end (uiout, "changed-registers");
952 if (argc == 0) /* No args, just do all the regs. */
958 if (gdbarch_register_name (gdbarch, regnum) == NULL
959 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
961 changed = register_changed_p (regnum, prev_regs, this_regs);
963 error ("mi_cmd_data_list_changed_registers: Unable to read register contents.");
965 ui_out_field_int (uiout, NULL, regnum);
969 /* Else, list of register #s, just do listed regs. */
970 for (i = 0; i < argc; i++)
972 regnum = atoi (argv[i]);
976 && gdbarch_register_name (gdbarch, regnum) != NULL
977 && *gdbarch_register_name (gdbarch, regnum) != '\000')
979 changed = register_changed_p (regnum, prev_regs, this_regs);
981 error ("mi_cmd_data_list_register_change: Unable to read register contents.");
983 ui_out_field_int (uiout, NULL, regnum);
986 error ("bad register number");
988 do_cleanups (cleanup);
992 register_changed_p (int regnum, struct regcache *prev_regs,
993 struct regcache *this_regs)
995 struct gdbarch *gdbarch = get_regcache_arch (this_regs);
996 gdb_byte prev_buffer[MAX_REGISTER_SIZE];
997 gdb_byte this_buffer[MAX_REGISTER_SIZE];
999 /* Registers not valid in this frame return count as unchanged. */
1000 if (!regcache_valid_p (this_regs, regnum))
1003 /* First time through or after gdbarch change consider all registers as
1004 changed. Same for registers not valid in the previous frame. */
1005 if (!prev_regs || get_regcache_arch (prev_regs) != gdbarch
1006 || !regcache_valid_p (prev_regs, regnum))
1009 /* Get register contents and compare. */
1010 regcache_cooked_read (prev_regs, regnum, prev_buffer);
1011 regcache_cooked_read (this_regs, regnum, this_buffer);
1013 return memcmp (prev_buffer, this_buffer,
1014 register_size (gdbarch, regnum)) != 0;
1017 /* Return a list of register number and value pairs. The valid
1018 arguments expected are: a letter indicating the format in which to
1019 display the registers contents. This can be one of: x (hexadecimal), d
1020 (decimal), N (natural), t (binary), o (octal), r (raw). After the
1021 format argumetn there can be a sequence of numbers, indicating which
1022 registers to fetch the content of. If the format is the only argument,
1023 a list of all the registers with their values is returned. */
1025 mi_cmd_data_list_register_values (char *command, char **argv, int argc)
1027 struct frame_info *frame;
1028 struct gdbarch *gdbarch;
1029 int regnum, numregs, format;
1031 struct cleanup *list_cleanup, *tuple_cleanup;
1033 /* Note that the test for a valid register must include checking the
1034 gdbarch_register_name because gdbarch_num_regs may be allocated for
1035 the union of the register sets within a family of related processors.
1036 In this case, some entries of gdbarch_register_name will change depending
1037 upon the particular processor being debugged. */
1040 error ("mi_cmd_data_list_register_values: Usage: -data-list-register-values <format> [<regnum1>...<regnumN>]");
1042 format = (int) argv[0][0];
1044 frame = get_selected_frame (NULL);
1045 gdbarch = get_frame_arch (frame);
1046 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
1048 list_cleanup = make_cleanup_ui_out_list_begin_end (uiout, "register-values");
1050 if (argc == 1) /* No args, beside the format: do all the regs. */
1056 if (gdbarch_register_name (gdbarch, regnum) == NULL
1057 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
1059 tuple_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1060 ui_out_field_int (uiout, "number", regnum);
1061 get_register (frame, regnum, format);
1062 do_cleanups (tuple_cleanup);
1066 /* Else, list of register #s, just do listed regs. */
1067 for (i = 1; i < argc; i++)
1069 regnum = atoi (argv[i]);
1073 && gdbarch_register_name (gdbarch, regnum) != NULL
1074 && *gdbarch_register_name (gdbarch, regnum) != '\000')
1076 tuple_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1077 ui_out_field_int (uiout, "number", regnum);
1078 get_register (frame, regnum, format);
1079 do_cleanups (tuple_cleanup);
1082 error ("bad register number");
1084 do_cleanups (list_cleanup);
1087 /* Output one register's contents in the desired format. */
1089 get_register (struct frame_info *frame, int regnum, int format)
1091 struct gdbarch *gdbarch = get_frame_arch (frame);
1092 gdb_byte buffer[MAX_REGISTER_SIZE];
1096 enum lval_type lval;
1097 static struct ui_stream *stb = NULL;
1099 stb = ui_out_stream_new (uiout);
1104 frame_register (frame, regnum, &optim, &lval, &addr, &realnum, buffer);
1107 error ("Optimized out");
1112 char *ptr, buf[1024];
1116 for (j = 0; j < register_size (gdbarch, regnum); j++)
1118 int idx = gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG ?
1119 j : register_size (gdbarch, regnum) - 1 - j;
1121 sprintf (ptr, "%02x", (unsigned char) buffer[idx]);
1124 ui_out_field_string (uiout, "value", buf);
1125 /*fputs_filtered (buf, gdb_stdout); */
1129 struct value_print_options opts;
1131 get_formatted_print_options (&opts, format);
1133 val_print (register_type (gdbarch, regnum), buffer, 0, 0,
1134 stb->stream, 0, NULL, &opts, current_language);
1135 ui_out_field_stream (uiout, "value", stb);
1136 ui_out_stream_delete (stb);
1140 /* Write given values into registers. The registers and values are
1141 given as pairs. The corresponding MI command is
1142 -data-write-register-values <format> [<regnum1> <value1>...<regnumN> <valueN>]*/
1144 mi_cmd_data_write_register_values (char *command, char **argv, int argc)
1146 struct regcache *regcache;
1147 struct gdbarch *gdbarch;
1151 /* Note that the test for a valid register must include checking the
1152 gdbarch_register_name because gdbarch_num_regs may be allocated for
1153 the union of the register sets within a family of related processors.
1154 In this case, some entries of gdbarch_register_name will change depending
1155 upon the particular processor being debugged. */
1157 regcache = get_current_regcache ();
1158 gdbarch = get_regcache_arch (regcache);
1159 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
1162 error ("mi_cmd_data_write_register_values: Usage: -data-write-register-values <format> [<regnum1> <value1>...<regnumN> <valueN>]");
1164 format = (int) argv[0][0];
1166 if (!target_has_registers)
1167 error ("mi_cmd_data_write_register_values: No registers.");
1170 error ("mi_cmd_data_write_register_values: No regs and values specified.");
1173 error ("mi_cmd_data_write_register_values: Regs and vals are not in pairs.");
1175 for (i = 1; i < argc; i = i + 2)
1177 int regnum = atoi (argv[i]);
1179 if (regnum >= 0 && regnum < numregs
1180 && gdbarch_register_name (gdbarch, regnum)
1181 && *gdbarch_register_name (gdbarch, regnum))
1185 /* Get the value as a number. */
1186 value = parse_and_eval_address (argv[i + 1]);
1188 /* Write it down. */
1189 regcache_cooked_write_signed (regcache, regnum, value);
1192 error ("bad register number");
1196 /* Evaluate the value of the argument. The argument is an
1197 expression. If the expression contains spaces it needs to be
1198 included in double quotes. */
1200 mi_cmd_data_evaluate_expression (char *command, char **argv, int argc)
1202 struct expression *expr;
1203 struct cleanup *old_chain = NULL;
1205 struct ui_stream *stb = NULL;
1206 struct value_print_options opts;
1208 stb = ui_out_stream_new (uiout);
1212 ui_out_stream_delete (stb);
1213 error ("mi_cmd_data_evaluate_expression: Usage: -data-evaluate-expression expression");
1216 expr = parse_expression (argv[0]);
1218 old_chain = make_cleanup (free_current_contents, &expr);
1220 val = evaluate_expression (expr);
1222 /* Print the result of the expression evaluation. */
1223 get_user_print_options (&opts);
1225 common_val_print (val, stb->stream, 0, &opts, current_language);
1227 ui_out_field_stream (uiout, "value", stb);
1228 ui_out_stream_delete (stb);
1230 do_cleanups (old_chain);
1233 /* DATA-MEMORY-READ:
1235 ADDR: start address of data to be dumped.
1236 WORD-FORMAT: a char indicating format for the ``word''. See
1238 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
1239 NR_ROW: Number of rows.
1240 NR_COL: The number of colums (words per row).
1241 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
1242 ASCHAR for unprintable characters.
1244 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
1245 displayes them. Returns:
1247 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
1250 The number of bytes read is SIZE*ROW*COL. */
1253 mi_cmd_data_read_memory (char *command, char **argv, int argc)
1255 struct gdbarch *gdbarch = get_current_arch ();
1256 struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
1262 struct type *word_type;
1275 static struct mi_opt opts[] =
1277 {"o", OFFSET_OPT, 1},
1283 int opt = mi_getopt ("mi_cmd_data_read_memory", argc, argv, opts,
1288 switch ((enum opt) opt)
1291 offset = atol (optarg);
1298 if (argc < 5 || argc > 6)
1299 error ("mi_cmd_data_read_memory: Usage: ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR].");
1301 /* Extract all the arguments. */
1303 /* Start address of the memory dump. */
1304 addr = parse_and_eval_address (argv[0]) + offset;
1305 /* The format character to use when displaying a memory word. See
1306 the ``x'' command. */
1307 word_format = argv[1][0];
1308 /* The size of the memory word. */
1309 word_size = atol (argv[2]);
1313 word_type = builtin_type (gdbarch)->builtin_int8;
1317 word_type = builtin_type (gdbarch)->builtin_int16;
1321 word_type = builtin_type (gdbarch)->builtin_int32;
1325 word_type = builtin_type (gdbarch)->builtin_int64;
1329 word_type = builtin_type (gdbarch)->builtin_int8;
1332 /* The number of rows. */
1333 nr_rows = atol (argv[3]);
1335 error ("mi_cmd_data_read_memory: invalid number of rows.");
1337 /* Number of bytes per row. */
1338 nr_cols = atol (argv[4]);
1340 error ("mi_cmd_data_read_memory: invalid number of columns.");
1342 /* The un-printable character when printing ascii. */
1348 /* Create a buffer and read it in. */
1349 total_bytes = word_size * nr_rows * nr_cols;
1350 mbuf = xcalloc (total_bytes, 1);
1351 make_cleanup (xfree, mbuf);
1353 /* Dispatch memory reads to the topmost target, not the flattened
1355 nr_bytes = target_read_until_error (current_target.beneath,
1356 TARGET_OBJECT_MEMORY, NULL, mbuf,
1359 error ("Unable to read memory.");
1361 /* Output the header information. */
1362 ui_out_field_core_addr (uiout, "addr", gdbarch, addr);
1363 ui_out_field_int (uiout, "nr-bytes", nr_bytes);
1364 ui_out_field_int (uiout, "total-bytes", total_bytes);
1365 ui_out_field_core_addr (uiout, "next-row",
1366 gdbarch, addr + word_size * nr_cols);
1367 ui_out_field_core_addr (uiout, "prev-row",
1368 gdbarch, addr - word_size * nr_cols);
1369 ui_out_field_core_addr (uiout, "next-page", gdbarch, addr + total_bytes);
1370 ui_out_field_core_addr (uiout, "prev-page", gdbarch, addr - total_bytes);
1372 /* Build the result as a two dimentional table. */
1374 struct ui_stream *stream = ui_out_stream_new (uiout);
1375 struct cleanup *cleanup_list_memory;
1379 cleanup_list_memory = make_cleanup_ui_out_list_begin_end (uiout, "memory");
1380 for (row = 0, row_byte = 0;
1382 row++, row_byte += nr_cols * word_size)
1386 struct cleanup *cleanup_tuple;
1387 struct cleanup *cleanup_list_data;
1388 struct value_print_options opts;
1390 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1391 ui_out_field_core_addr (uiout, "addr", gdbarch, addr + row_byte);
1392 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr + row_byte); */
1393 cleanup_list_data = make_cleanup_ui_out_list_begin_end (uiout, "data");
1394 get_formatted_print_options (&opts, word_format);
1395 for (col = 0, col_byte = row_byte;
1397 col++, col_byte += word_size)
1399 if (col_byte + word_size > nr_bytes)
1401 ui_out_field_string (uiout, NULL, "N/A");
1405 ui_file_rewind (stream->stream);
1406 print_scalar_formatted (mbuf + col_byte, word_type, &opts,
1407 word_asize, stream->stream);
1408 ui_out_field_stream (uiout, NULL, stream);
1411 do_cleanups (cleanup_list_data);
1416 ui_file_rewind (stream->stream);
1417 for (byte = row_byte; byte < row_byte + word_size * nr_cols; byte++)
1419 if (byte >= nr_bytes)
1421 fputc_unfiltered ('X', stream->stream);
1423 else if (mbuf[byte] < 32 || mbuf[byte] > 126)
1425 fputc_unfiltered (aschar, stream->stream);
1428 fputc_unfiltered (mbuf[byte], stream->stream);
1430 ui_out_field_stream (uiout, "ascii", stream);
1432 do_cleanups (cleanup_tuple);
1434 ui_out_stream_delete (stream);
1435 do_cleanups (cleanup_list_memory);
1437 do_cleanups (cleanups);
1440 /* DATA-MEMORY-WRITE:
1442 COLUMN_OFFSET: optional argument. Must be preceeded by '-o'. The
1443 offset from the beginning of the memory grid row where the cell to
1445 ADDR: start address of the row in the memory grid where the memory
1446 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
1447 the location to write to.
1448 FORMAT: a char indicating format for the ``word''. See
1450 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
1451 VALUE: value to be written into the memory address.
1453 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1457 mi_cmd_data_write_memory (char *command, char **argv, int argc)
1459 struct gdbarch *gdbarch = get_current_arch ();
1460 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1464 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1465 enough when using a compiler other than GCC. */
1468 struct cleanup *old_chain;
1476 static struct mi_opt opts[] =
1478 {"o", OFFSET_OPT, 1},
1484 int opt = mi_getopt ("mi_cmd_data_write_memory", argc, argv, opts,
1489 switch ((enum opt) opt)
1492 offset = atol (optarg);
1500 error ("mi_cmd_data_write_memory: Usage: [-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE.");
1502 /* Extract all the arguments. */
1503 /* Start address of the memory dump. */
1504 addr = parse_and_eval_address (argv[0]);
1505 /* The format character to use when displaying a memory word. See
1506 the ``x'' command. */
1507 word_format = argv[1][0];
1508 /* The size of the memory word. */
1509 word_size = atol (argv[2]);
1511 /* Calculate the real address of the write destination. */
1512 addr += (offset * word_size);
1514 /* Get the value as a number. */
1515 value = parse_and_eval_address (argv[3]);
1516 /* Get the value into an array. */
1517 buffer = xmalloc (word_size);
1518 old_chain = make_cleanup (xfree, buffer);
1519 store_signed_integer (buffer, word_size, byte_order, value);
1520 /* Write it down to memory. */
1521 write_memory (addr, buffer, word_size);
1522 /* Free the buffer. */
1523 do_cleanups (old_chain);
1527 mi_cmd_enable_timings (char *command, char **argv, int argc)
1533 if (strcmp (argv[0], "yes") == 0)
1535 else if (strcmp (argv[0], "no") == 0)
1546 error ("mi_cmd_enable_timings: Usage: %s {yes|no}", command);
1550 mi_cmd_list_features (char *command, char **argv, int argc)
1554 struct cleanup *cleanup = NULL;
1556 cleanup = make_cleanup_ui_out_list_begin_end (uiout, "features");
1557 ui_out_field_string (uiout, NULL, "frozen-varobjs");
1558 ui_out_field_string (uiout, NULL, "pending-breakpoints");
1559 ui_out_field_string (uiout, NULL, "thread-info");
1562 ui_out_field_string (uiout, NULL, "python");
1565 do_cleanups (cleanup);
1569 error ("-list-features should be passed no arguments");
1573 mi_cmd_list_target_features (char *command, char **argv, int argc)
1577 struct cleanup *cleanup = NULL;
1579 cleanup = make_cleanup_ui_out_list_begin_end (uiout, "features");
1580 if (target_can_async_p ())
1581 ui_out_field_string (uiout, NULL, "async");
1583 do_cleanups (cleanup);
1587 error ("-list-target-features should be passed no arguments");
1591 mi_cmd_add_inferior (char *command, char **argv, int argc)
1593 struct inferior *inf;
1596 error (_("-add-inferior should be passed no arguments"));
1598 inf = add_inferior_with_spaces ();
1600 ui_out_field_fmt (uiout, "inferior", "i%d", inf->num);
1604 mi_cmd_remove_inferior (char *command, char **argv, int argc)
1607 struct inferior *inf;
1610 error ("-remove-inferior should be passed a single argument");
1612 if (sscanf (argv[0], "i%d", &id) != 1)
1613 error ("the thread group id is syntactically invalid");
1615 inf = find_inferior_id (id);
1617 error ("the specified thread group does not exist");
1619 delete_inferior_1 (inf, 1 /* silent */);
1624 /* Execute a command within a safe environment.
1625 Return <0 for error; >=0 for ok.
1627 args->action will tell mi_execute_command what action
1628 to perfrom after the given command has executed (display/suppress
1629 prompt, display error). */
1632 captured_mi_execute_command (struct ui_out *uiout, void *data)
1634 struct cleanup *cleanup;
1635 struct mi_parse *context = (struct mi_parse *) data;
1638 current_command_ts = context->cmd_start;
1640 current_token = xstrdup (context->token);
1641 cleanup = make_cleanup (free_current_contents, ¤t_token);
1643 running_result_record_printed = 0;
1645 switch (context->op)
1648 /* A MI command was read from the input stream. */
1650 /* FIXME: gdb_???? */
1651 fprintf_unfiltered (raw_stdout, " token=`%s' command=`%s' args=`%s'\n",
1652 context->token, context->command, context->args);
1655 mi_cmd_execute (context);
1657 /* Print the result if there were no errors.
1659 Remember that on the way out of executing a command, you have
1660 to directly use the mi_interp's uiout, since the command could
1661 have reset the interpreter, in which case the current uiout
1662 will most likely crash in the mi_out_* routines. */
1663 if (!running_result_record_printed)
1665 fputs_unfiltered (context->token, raw_stdout);
1666 /* There's no particularly good reason why target-connect results
1667 in not ^done. Should kill ^connected for MI3. */
1668 fputs_unfiltered (strcmp (context->command, "target-select") == 0
1669 ? "^connected" : "^done", raw_stdout);
1670 mi_out_put (uiout, raw_stdout);
1671 mi_out_rewind (uiout);
1672 mi_print_timing_maybe ();
1673 fputs_unfiltered ("\n", raw_stdout);
1676 /* The command does not want anything to be printed. In that
1677 case, the command probably should not have written anything
1678 to uiout, but in case it has written something, discard it. */
1679 mi_out_rewind (uiout);
1686 /* A CLI command was read from the input stream. */
1687 /* This "feature" will be removed as soon as we have a
1688 complete set of mi commands. */
1689 /* Echo the command on the console. */
1690 fprintf_unfiltered (gdb_stdlog, "%s\n", context->command);
1691 /* Call the "console" interpreter. */
1692 argv[0] = "console";
1693 argv[1] = context->command;
1694 mi_cmd_interpreter_exec ("-interpreter-exec", argv, 2);
1696 /* If we changed interpreters, DON'T print out anything. */
1697 if (current_interp_named_p (INTERP_MI)
1698 || current_interp_named_p (INTERP_MI1)
1699 || current_interp_named_p (INTERP_MI2)
1700 || current_interp_named_p (INTERP_MI3))
1702 if (!running_result_record_printed)
1704 fputs_unfiltered (context->token, raw_stdout);
1705 fputs_unfiltered ("^done", raw_stdout);
1706 mi_out_put (uiout, raw_stdout);
1707 mi_out_rewind (uiout);
1708 mi_print_timing_maybe ();
1709 fputs_unfiltered ("\n", raw_stdout);
1712 mi_out_rewind (uiout);
1719 do_cleanups (cleanup);
1726 mi_execute_command (char *cmd, int from_tty)
1728 struct mi_parse *command;
1730 /* This is to handle EOF (^D). We just quit gdb. */
1731 /* FIXME: we should call some API function here. */
1733 quit_force (NULL, from_tty);
1735 target_log_command (cmd);
1737 command = mi_parse (cmd);
1739 if (command != NULL)
1741 struct gdb_exception result;
1742 ptid_t previous_ptid = inferior_ptid;
1746 command->cmd_start = (struct mi_timestamp *)
1747 xmalloc (sizeof (struct mi_timestamp));
1748 timestamp (command->cmd_start);
1751 result = catch_exception (uiout, captured_mi_execute_command, command,
1753 if (result.reason < 0)
1755 /* The command execution failed and error() was called
1757 fputs_unfiltered (command->token, raw_stdout);
1758 fputs_unfiltered ("^error,msg=\"", raw_stdout);
1759 if (result.message == NULL)
1760 fputs_unfiltered ("unknown error", raw_stdout);
1762 fputstr_unfiltered (result.message, '"', raw_stdout);
1763 fputs_unfiltered ("\"\n", raw_stdout);
1764 mi_out_rewind (uiout);
1767 bpstat_do_actions ();
1769 if (/* The notifications are only output when the top-level
1770 interpreter (specified on the command line) is MI. */
1771 ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ()))
1772 /* Don't try report anything if there are no threads --
1773 the program is dead. */
1774 && thread_count () != 0
1775 /* -thread-select explicitly changes thread. If frontend uses that
1776 internally, we don't want to emit =thread-selected, since
1777 =thread-selected is supposed to indicate user's intentions. */
1778 && strcmp (command->command, "thread-select") != 0)
1780 struct mi_interp *mi = top_level_interpreter_data ();
1781 int report_change = 0;
1783 if (command->thread == -1)
1785 report_change = (!ptid_equal (previous_ptid, null_ptid)
1786 && !ptid_equal (inferior_ptid, previous_ptid)
1787 && !ptid_equal (inferior_ptid, null_ptid));
1789 else if (!ptid_equal (inferior_ptid, null_ptid))
1791 struct thread_info *ti = inferior_thread ();
1793 report_change = (ti->num != command->thread);
1798 struct thread_info *ti = inferior_thread ();
1800 target_terminal_ours ();
1801 fprintf_unfiltered (mi->event_channel,
1802 "thread-selected,id=\"%d\"",
1804 gdb_flush (mi->event_channel);
1808 mi_parse_free (command);
1811 fputs_unfiltered ("(gdb) \n", raw_stdout);
1812 gdb_flush (raw_stdout);
1813 /* Print any buffered hook code. */
1818 mi_cmd_execute (struct mi_parse *parse)
1820 struct cleanup *cleanup;
1822 prepare_execute_command ();
1824 cleanup = make_cleanup (null_cleanup, NULL);
1826 if (parse->all && parse->thread_group != -1)
1827 error (_("Cannot specify --thread-group together with --all"));
1829 if (parse->all && parse->thread != -1)
1830 error (_("Cannot specify --thread together with --all"));
1832 if (parse->thread_group != -1 && parse->thread != -1)
1833 error (_("Cannot specify --thread together with --thread-group"));
1835 if (parse->frame != -1 && parse->thread == -1)
1836 error (_("Cannot specify --frame without --thread"));
1838 if (parse->thread_group != -1)
1840 struct inferior *inf = find_inferior_id (parse->thread_group);
1841 struct thread_info *tp = 0;
1844 error (_("Invalid thread group for the --thread-group option"));
1846 set_current_inferior (inf);
1847 /* This behaviour means that if --thread-group option identifies
1848 an inferior with multiple threads, then a random one will be picked.
1849 This is not a problem -- frontend should always provide --thread if
1850 it wishes to operate on a specific thread. */
1852 tp = any_thread_of_process (inf->pid);
1853 switch_to_thread (tp ? tp->ptid : null_ptid);
1854 set_current_program_space (inf->pspace);
1857 if (parse->thread != -1)
1859 struct thread_info *tp = find_thread_id (parse->thread);
1862 error (_("Invalid thread id: %d"), parse->thread);
1864 if (is_exited (tp->ptid))
1865 error (_("Thread id: %d has terminated"), parse->thread);
1867 switch_to_thread (tp->ptid);
1870 if (parse->frame != -1)
1872 struct frame_info *fid;
1873 int frame = parse->frame;
1875 fid = find_relative_frame (get_current_frame (), &frame);
1877 /* find_relative_frame was successful */
1880 error (_("Invalid frame id: %d"), frame);
1883 current_context = parse;
1885 if (parse->cmd->argv_func != NULL)
1886 parse->cmd->argv_func (parse->command, parse->argv, parse->argc);
1887 else if (parse->cmd->cli.cmd != 0)
1889 /* FIXME: DELETE THIS. */
1890 /* The operation is still implemented by a cli command. */
1891 /* Must be a synchronous one. */
1892 mi_execute_cli_command (parse->cmd->cli.cmd, parse->cmd->cli.args_p,
1897 /* FIXME: DELETE THIS. */
1898 struct ui_file *stb;
1900 stb = mem_fileopen ();
1902 fputs_unfiltered ("Undefined mi command: ", stb);
1903 fputstr_unfiltered (parse->command, '"', stb);
1904 fputs_unfiltered (" (missing implementation)", stb);
1906 make_cleanup_ui_file_delete (stb);
1909 do_cleanups (cleanup);
1912 /* FIXME: This is just a hack so we can get some extra commands going.
1913 We don't want to channel things through the CLI, but call libgdb directly.
1914 Use only for synchronous commands. */
1917 mi_execute_cli_command (const char *cmd, int args_p, const char *args)
1921 struct cleanup *old_cleanups;
1925 run = xstrprintf ("%s %s", cmd, args);
1927 run = xstrdup (cmd);
1929 /* FIXME: gdb_???? */
1930 fprintf_unfiltered (gdb_stdout, "cli=%s run=%s\n",
1932 old_cleanups = make_cleanup (xfree, run);
1933 execute_command ( /*ui */ run, 0 /*from_tty */ );
1934 do_cleanups (old_cleanups);
1940 mi_execute_async_cli_command (char *cli_command, char **argv, int argc)
1942 struct cleanup *old_cleanups;
1945 if (target_can_async_p ())
1946 run = xstrprintf ("%s %s&", cli_command, argc ? *argv : "");
1948 run = xstrprintf ("%s %s", cli_command, argc ? *argv : "");
1949 old_cleanups = make_cleanup (xfree, run);
1951 execute_command ( /*ui */ run, 0 /*from_tty */ );
1953 if (target_can_async_p ())
1955 /* If we're not executing, an exception should have been throw. */
1956 gdb_assert (is_running (inferior_ptid));
1957 do_cleanups (old_cleanups);
1961 /* Do this before doing any printing. It would appear that some
1962 print code leaves garbage around in the buffer. */
1963 do_cleanups (old_cleanups);
1968 mi_load_progress (const char *section_name,
1969 unsigned long sent_so_far,
1970 unsigned long total_section,
1971 unsigned long total_sent,
1972 unsigned long grand_total)
1974 struct timeval time_now, delta, update_threshold;
1975 static struct timeval last_update;
1976 static char *previous_sect_name = NULL;
1978 struct ui_out *saved_uiout;
1980 /* This function is called through deprecated_show_load_progress
1981 which means uiout may not be correct. Fix it for the duration
1982 of this function. */
1983 saved_uiout = uiout;
1985 if (current_interp_named_p (INTERP_MI)
1986 || current_interp_named_p (INTERP_MI2))
1987 uiout = mi_out_new (2);
1988 else if (current_interp_named_p (INTERP_MI1))
1989 uiout = mi_out_new (1);
1990 else if (current_interp_named_p (INTERP_MI3))
1991 uiout = mi_out_new (3);
1995 update_threshold.tv_sec = 0;
1996 update_threshold.tv_usec = 500000;
1997 gettimeofday (&time_now, NULL);
1999 delta.tv_usec = time_now.tv_usec - last_update.tv_usec;
2000 delta.tv_sec = time_now.tv_sec - last_update.tv_sec;
2002 if (delta.tv_usec < 0)
2005 delta.tv_usec += 1000000L;
2008 new_section = (previous_sect_name ?
2009 strcmp (previous_sect_name, section_name) : 1);
2012 struct cleanup *cleanup_tuple;
2014 xfree (previous_sect_name);
2015 previous_sect_name = xstrdup (section_name);
2018 fputs_unfiltered (current_token, raw_stdout);
2019 fputs_unfiltered ("+download", raw_stdout);
2020 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
2021 ui_out_field_string (uiout, "section", section_name);
2022 ui_out_field_int (uiout, "section-size", total_section);
2023 ui_out_field_int (uiout, "total-size", grand_total);
2024 do_cleanups (cleanup_tuple);
2025 mi_out_put (uiout, raw_stdout);
2026 fputs_unfiltered ("\n", raw_stdout);
2027 gdb_flush (raw_stdout);
2030 if (delta.tv_sec >= update_threshold.tv_sec &&
2031 delta.tv_usec >= update_threshold.tv_usec)
2033 struct cleanup *cleanup_tuple;
2035 last_update.tv_sec = time_now.tv_sec;
2036 last_update.tv_usec = time_now.tv_usec;
2038 fputs_unfiltered (current_token, raw_stdout);
2039 fputs_unfiltered ("+download", raw_stdout);
2040 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
2041 ui_out_field_string (uiout, "section", section_name);
2042 ui_out_field_int (uiout, "section-sent", sent_so_far);
2043 ui_out_field_int (uiout, "section-size", total_section);
2044 ui_out_field_int (uiout, "total-sent", total_sent);
2045 ui_out_field_int (uiout, "total-size", grand_total);
2046 do_cleanups (cleanup_tuple);
2047 mi_out_put (uiout, raw_stdout);
2048 fputs_unfiltered ("\n", raw_stdout);
2049 gdb_flush (raw_stdout);
2053 uiout = saved_uiout;
2057 timestamp (struct mi_timestamp *tv)
2059 gettimeofday (&tv->wallclock, NULL);
2060 #ifdef HAVE_GETRUSAGE
2061 getrusage (RUSAGE_SELF, &rusage);
2062 tv->utime.tv_sec = rusage.ru_utime.tv_sec;
2063 tv->utime.tv_usec = rusage.ru_utime.tv_usec;
2064 tv->stime.tv_sec = rusage.ru_stime.tv_sec;
2065 tv->stime.tv_usec = rusage.ru_stime.tv_usec;
2068 long usec = get_run_time ();
2070 tv->utime.tv_sec = usec/1000000L;
2071 tv->utime.tv_usec = usec - 1000000L*tv->utime.tv_sec;
2072 tv->stime.tv_sec = 0;
2073 tv->stime.tv_usec = 0;
2079 print_diff_now (struct mi_timestamp *start)
2081 struct mi_timestamp now;
2084 print_diff (start, &now);
2088 mi_print_timing_maybe (void)
2090 /* If the command is -enable-timing then do_timings may be
2091 true whilst current_command_ts is not initialized. */
2092 if (do_timings && current_command_ts)
2093 print_diff_now (current_command_ts);
2097 timeval_diff (struct timeval start, struct timeval end)
2099 return ((end.tv_sec - start.tv_sec) * 1000000L)
2100 + (end.tv_usec - start.tv_usec);
2104 print_diff (struct mi_timestamp *start, struct mi_timestamp *end)
2108 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
2109 timeval_diff (start->wallclock, end->wallclock) / 1000000.0,
2110 timeval_diff (start->utime, end->utime) / 1000000.0,
2111 timeval_diff (start->stime, end->stime) / 1000000.0);
2115 mi_cmd_trace_define_variable (char *command, char **argv, int argc)
2117 struct expression *expr;
2118 struct cleanup *back_to;
2119 LONGEST initval = 0;
2120 struct trace_state_variable *tsv;
2123 if (argc != 1 && argc != 2)
2124 error (_("Usage: -trace-define-variable VARIABLE [VALUE]"));
2126 expr = parse_expression (argv[0]);
2127 back_to = make_cleanup (xfree, expr);
2129 if (expr->nelts == 3 && expr->elts[0].opcode == OP_INTERNALVAR)
2131 struct internalvar *intvar = expr->elts[1].internalvar;
2134 name = internalvar_name (intvar);
2137 if (!name || *name == '\0')
2138 error (_("Invalid name of trace variable"));
2140 tsv = find_trace_state_variable (name);
2142 tsv = create_trace_state_variable (name);
2145 initval = value_as_long (parse_and_eval (argv[1]));
2147 tsv->initial_value = initval;
2149 do_cleanups (back_to);
2153 mi_cmd_trace_list_variables (char *command, char **argv, int argc)
2156 error (_("-trace-list-variables: no arguments are allowed"));
2158 tvariables_info_1 ();
2162 mi_cmd_trace_find (char *command, char **argv, int argc)
2167 error (_("trace selection mode is required"));
2171 if (strcmp (mode, "none") == 0)
2173 tfind_1 (tfind_number, -1, 0, 0, 0);
2177 if (current_trace_status ()->running)
2178 error (_("May not look at trace frames while trace is running."));
2180 if (strcmp (mode, "frame-number") == 0)
2183 error (_("frame number is required"));
2184 tfind_1 (tfind_number, atoi (argv[1]), 0, 0, 0);
2186 else if (strcmp (mode, "tracepoint-number") == 0)
2189 error (_("tracepoint number is required"));
2190 tfind_1 (tfind_tp, atoi (argv[1]), 0, 0, 0);
2192 else if (strcmp (mode, "pc") == 0)
2195 error (_("PC is required"));
2196 tfind_1 (tfind_pc, 0, parse_and_eval_address (argv[1]), 0, 0);
2198 else if (strcmp (mode, "pc-inside-range") == 0)
2201 error (_("Start and end PC are required"));
2202 tfind_1 (tfind_range, 0, parse_and_eval_address (argv[1]),
2203 parse_and_eval_address (argv[2]), 0);
2205 else if (strcmp (mode, "pc-outside-range") == 0)
2208 error (_("Start and end PC are required"));
2209 tfind_1 (tfind_outside, 0, parse_and_eval_address (argv[1]),
2210 parse_and_eval_address (argv[2]), 0);
2212 else if (strcmp (mode, "line") == 0)
2214 struct symtabs_and_lines sals;
2215 struct symtab_and_line sal;
2216 static CORE_ADDR start_pc, end_pc;
2217 struct cleanup *back_to;
2220 error (_("Line is required"));
2222 sals = decode_line_spec (argv[1], 1);
2223 back_to = make_cleanup (xfree, sals.sals);
2227 if (sal.symtab == 0)
2228 error (_("Could not find the specified line"));
2230 if (sal.line > 0 && find_line_pc_range (sal, &start_pc, &end_pc))
2231 tfind_1 (tfind_range, 0, start_pc, end_pc - 1, 0);
2233 error (_("Could not find the specified line"));
2235 do_cleanups (back_to);
2238 error (_("Invalid mode '%s'"), mode);
2240 if (has_stack_frames () || get_traceframe_number () >= 0)
2242 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
2247 mi_cmd_trace_save (char *command, char **argv, int argc)
2249 int target_saves = 0;
2252 if (argc != 1 && argc != 2)
2253 error (_("Usage: -trace-save [-r] filename"));
2258 if (strcmp (argv[0], "-r") == 0)
2261 error (_("Invalid option: %s"), argv[0]);
2268 trace_save (filename, target_saves);
2273 mi_cmd_trace_start (char *command, char **argv, int argc)
2279 mi_cmd_trace_status (char *command, char **argv, int argc)
2281 trace_status_mi (0);
2285 mi_cmd_trace_stop (char *command, char **argv, int argc)
2288 trace_status_mi (1);