3 Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010,
4 2011 Free Software Foundation, Inc.
6 Contributed by Cygnus Solutions (a Red Hat company).
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 /* Work in progress. */
26 #include "arch-utils.h"
29 #include "gdb_string.h"
30 #include "exceptions.h"
32 #include "gdbthread.h"
35 #include "mi-getopt.h"
36 #include "mi-console.h"
40 #include "event-loop.h"
41 #include "event-top.h"
42 #include "gdbcore.h" /* For write_memory(). */
48 #include "mi-common.h"
53 #include "splay-tree.h"
54 #include "tracepoint.h"
59 #if defined HAVE_SYS_RESOURCE_H
60 #include <sys/resource.h>
73 struct ui_file *raw_stdout;
75 /* This is used to pass the current command timestamp
76 down to continuation routines. */
77 static struct mi_timestamp *current_command_ts;
79 static int do_timings = 0;
82 /* Few commands would like to know if options like --thread-group
83 were explicitly specified. This variable keeps the current
84 parsed command including all option, and make it possible. */
85 static struct mi_parse *current_context;
87 int running_result_record_printed = 1;
89 /* Flag indicating that the target has proceeded since the last
90 command was issued. */
93 extern void _initialize_mi_main (void);
94 static void mi_cmd_execute (struct mi_parse *parse);
96 static void mi_execute_cli_command (const char *cmd, int args_p,
98 static void mi_execute_async_cli_command (char *cli_command,
99 char **argv, int argc);
100 static int register_changed_p (int regnum, struct regcache *,
102 static void get_register (struct frame_info *, int regnum, int format);
104 /* Command implementations. FIXME: Is this libgdb? No. This is the MI
105 layer that calls libgdb. Any operation used in the below should be
108 static void timestamp (struct mi_timestamp *tv);
110 static void print_diff_now (struct mi_timestamp *start);
111 static void print_diff (struct mi_timestamp *start, struct mi_timestamp *end);
114 mi_cmd_gdb_exit (char *command, char **argv, int argc)
116 /* We have to print everything right here because we never return. */
118 fputs_unfiltered (current_token, raw_stdout);
119 fputs_unfiltered ("^exit\n", raw_stdout);
120 mi_out_put (uiout, raw_stdout);
121 gdb_flush (raw_stdout);
122 /* FIXME: The function called is not yet a formal libgdb function. */
123 quit_force (NULL, FROM_TTY);
127 mi_cmd_exec_next (char *command, char **argv, int argc)
129 /* FIXME: Should call a libgdb function, not a cli wrapper. */
130 if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
131 mi_execute_async_cli_command ("reverse-next", argv + 1, argc - 1);
133 mi_execute_async_cli_command ("next", argv, argc);
137 mi_cmd_exec_next_instruction (char *command, char **argv, int argc)
139 /* FIXME: Should call a libgdb function, not a cli wrapper. */
140 if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
141 mi_execute_async_cli_command ("reverse-nexti", argv + 1, argc - 1);
143 mi_execute_async_cli_command ("nexti", argv, argc);
147 mi_cmd_exec_step (char *command, char **argv, int argc)
149 /* FIXME: Should call a libgdb function, not a cli wrapper. */
150 if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
151 mi_execute_async_cli_command ("reverse-step", argv + 1, argc - 1);
153 mi_execute_async_cli_command ("step", argv, argc);
157 mi_cmd_exec_step_instruction (char *command, char **argv, int argc)
159 /* FIXME: Should call a libgdb function, not a cli wrapper. */
160 if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
161 mi_execute_async_cli_command ("reverse-stepi", argv + 1, argc - 1);
163 mi_execute_async_cli_command ("stepi", argv, argc);
167 mi_cmd_exec_finish (char *command, char **argv, int argc)
169 /* FIXME: Should call a libgdb function, not a cli wrapper. */
170 if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
171 mi_execute_async_cli_command ("reverse-finish", argv + 1, argc - 1);
173 mi_execute_async_cli_command ("finish", argv, argc);
177 mi_cmd_exec_return (char *command, char **argv, int argc)
179 /* This command doesn't really execute the target, it just pops the
180 specified number of frames. */
182 /* Call return_command with from_tty argument equal to 0 so as to
183 avoid being queried. */
184 return_command (*argv, 0);
186 /* Call return_command with from_tty argument equal to 0 so as to
187 avoid being queried. */
188 return_command (NULL, 0);
190 /* Because we have called return_command with from_tty = 0, we need
191 to print the frame here. */
192 print_stack_frame (get_selected_frame (NULL), 1, LOC_AND_ADDRESS);
196 mi_cmd_exec_jump (char *args, char **argv, int argc)
198 /* FIXME: Should call a libgdb function, not a cli wrapper. */
199 mi_execute_async_cli_command ("jump", argv, argc);
203 proceed_thread (struct thread_info *thread, int pid)
205 if (!is_stopped (thread->ptid))
208 if (pid != 0 && PIDGET (thread->ptid) != pid)
211 switch_to_thread (thread->ptid);
212 clear_proceed_status ();
213 proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 0);
218 proceed_thread_callback (struct thread_info *thread, void *arg)
220 int pid = *(int *)arg;
222 proceed_thread (thread, pid);
227 exec_continue (char **argv, int argc)
231 /* In non-stop mode, 'resume' always resumes a single thread. Therefore,
232 to resume all threads of the current inferior, or all threads in all
233 inferiors, we need to iterate over threads.
235 See comment on infcmd.c:proceed_thread_callback for rationale. */
236 if (current_context->all || current_context->thread_group != -1)
239 struct cleanup *back_to = make_cleanup_restore_current_thread ();
241 if (!current_context->all)
244 = find_inferior_id (current_context->thread_group);
248 iterate_over_threads (proceed_thread_callback, &pid);
249 do_cleanups (back_to);
258 struct cleanup *back_to = make_cleanup_restore_integer (&sched_multi);
260 if (current_context->all)
267 /* In all-stop mode, -exec-continue traditionally resumed either
268 all threads, or one thread, depending on the 'scheduler-locking'
269 variable. Let's continue to do the same. */
272 do_cleanups (back_to);
277 exec_direction_forward (void *notused)
279 execution_direction = EXEC_FORWARD;
283 exec_reverse_continue (char **argv, int argc)
285 enum exec_direction_kind dir = execution_direction;
286 struct cleanup *old_chain;
288 if (dir == EXEC_REVERSE)
289 error (_("Already in reverse mode."));
291 if (!target_can_execute_reverse)
292 error (_("Target %s does not support this command."), target_shortname);
294 old_chain = make_cleanup (exec_direction_forward, NULL);
295 execution_direction = EXEC_REVERSE;
296 exec_continue (argv, argc);
297 do_cleanups (old_chain);
301 mi_cmd_exec_continue (char *command, char **argv, int argc)
303 if (argc > 0 && strcmp (argv[0], "--reverse") == 0)
304 exec_reverse_continue (argv + 1, argc - 1);
306 exec_continue (argv, argc);
310 interrupt_thread_callback (struct thread_info *thread, void *arg)
312 int pid = *(int *)arg;
314 if (!is_running (thread->ptid))
317 if (PIDGET (thread->ptid) != pid)
320 target_stop (thread->ptid);
324 /* Interrupt the execution of the target. Note how we must play around
325 with the token variables, in order to display the current token in
326 the result of the interrupt command, and the previous execution
327 token when the target finally stops. See comments in
330 mi_cmd_exec_interrupt (char *command, char **argv, int argc)
332 /* In all-stop mode, everything stops, so we don't need to try
333 anything specific. */
336 interrupt_target_1 (0);
340 if (current_context->all)
342 /* This will interrupt all threads in all inferiors. */
343 interrupt_target_1 (1);
345 else if (current_context->thread_group != -1)
347 struct inferior *inf = find_inferior_id (current_context->thread_group);
349 iterate_over_threads (interrupt_thread_callback, &inf->pid);
353 /* Interrupt just the current thread -- either explicitly
354 specified via --thread or whatever was current before
355 MI command was sent. */
356 interrupt_target_1 (0);
361 run_one_inferior (struct inferior *inf, void *arg)
365 if (inf->pid != ptid_get_pid (inferior_ptid))
367 struct thread_info *tp;
369 tp = any_thread_of_process (inf->pid);
371 error (_("Inferior has no threads."));
373 switch_to_thread (tp->ptid);
378 set_current_inferior (inf);
379 switch_to_thread (null_ptid);
380 set_current_program_space (inf->pspace);
382 mi_execute_cli_command ("run", target_can_async_p (),
383 target_can_async_p () ? "&" : NULL);
388 mi_cmd_exec_run (char *command, char **argv, int argc)
390 if (current_context->all)
392 struct cleanup *back_to = save_current_space_and_thread ();
394 iterate_over_inferiors (run_one_inferior, NULL);
395 do_cleanups (back_to);
399 mi_execute_cli_command ("run", target_can_async_p (),
400 target_can_async_p () ? "&" : NULL);
406 find_thread_of_process (struct thread_info *ti, void *p)
410 if (PIDGET (ti->ptid) == pid && !is_exited (ti->ptid))
417 mi_cmd_target_detach (char *command, char **argv, int argc)
419 if (argc != 0 && argc != 1)
420 error (_("Usage: -target-detach [pid | thread-group]"));
424 struct thread_info *tp;
428 /* First see if we are dealing with a thread-group id. */
431 struct inferior *inf;
432 int id = strtoul (argv[0] + 1, &end, 0);
435 error (_("Invalid syntax of thread-group id '%s'"), argv[0]);
437 inf = find_inferior_id (id);
439 error (_("Non-existent thread-group id '%d'"), id);
445 /* We must be dealing with a pid. */
446 pid = strtol (argv[0], &end, 10);
449 error (_("Invalid identifier '%s'"), argv[0]);
452 /* Pick any thread in the desired process. Current
453 target_detach detaches from the parent of inferior_ptid. */
454 tp = iterate_over_threads (find_thread_of_process, &pid);
456 error (_("Thread group is empty"));
458 switch_to_thread (tp->ptid);
461 detach_command (NULL, 0);
465 mi_cmd_thread_select (char *command, char **argv, int argc)
468 char *mi_error_message;
471 error (_("-thread-select: USAGE: threadnum."));
473 rc = gdb_thread_select (uiout, argv[0], &mi_error_message);
475 if (rc == GDB_RC_FAIL)
477 make_cleanup (xfree, mi_error_message);
478 error ("%s", mi_error_message);
483 mi_cmd_thread_list_ids (char *command, char **argv, int argc)
486 char *mi_error_message;
489 error (_("-thread-list-ids: No arguments required."));
491 rc = gdb_list_thread_ids (uiout, &mi_error_message);
493 if (rc == GDB_RC_FAIL)
495 make_cleanup (xfree, mi_error_message);
496 error ("%s", mi_error_message);
501 mi_cmd_thread_info (char *command, char **argv, int argc)
503 if (argc != 0 && argc != 1)
504 error (_("Invalid MI command"));
506 print_thread_info (uiout, argv[0], -1);
509 struct collect_cores_data
517 collect_cores (struct thread_info *ti, void *xdata)
519 struct collect_cores_data *data = xdata;
521 if (ptid_get_pid (ti->ptid) == data->pid)
523 int core = target_core_of_thread (ti->ptid);
526 VEC_safe_push (int, data->cores, core);
533 unique (int *b, int *e)
543 struct print_one_inferior_data
546 VEC (int) *inferiors;
550 print_one_inferior (struct inferior *inferior, void *xdata)
552 struct print_one_inferior_data *top_data = xdata;
554 if (VEC_empty (int, top_data->inferiors)
555 || bsearch (&(inferior->pid), VEC_address (int, top_data->inferiors),
556 VEC_length (int, top_data->inferiors), sizeof (int),
557 compare_positive_ints))
559 struct collect_cores_data data;
560 struct cleanup *back_to
561 = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
563 ui_out_field_fmt (uiout, "id", "i%d", inferior->num);
564 ui_out_field_string (uiout, "type", "process");
565 if (inferior->pid != 0)
566 ui_out_field_int (uiout, "pid", inferior->pid);
568 if (inferior->pspace->ebfd)
570 ui_out_field_string (uiout, "executable",
571 bfd_get_filename (inferior->pspace->ebfd));
575 if (inferior->pid != 0)
577 data.pid = inferior->pid;
578 iterate_over_threads (collect_cores, &data);
581 if (!VEC_empty (int, data.cores))
584 struct cleanup *back_to_2 =
585 make_cleanup_ui_out_list_begin_end (uiout, "cores");
587 qsort (VEC_address (int, data.cores),
588 VEC_length (int, data.cores), sizeof (int),
589 compare_positive_ints);
591 b = VEC_address (int, data.cores);
592 e = b + VEC_length (int, data.cores);
596 ui_out_field_int (uiout, NULL, *b);
598 do_cleanups (back_to_2);
601 if (top_data->recurse)
602 print_thread_info (uiout, NULL, inferior->pid);
604 do_cleanups (back_to);
610 /* Output a field named 'cores' with a list as the value. The elements of
611 the list are obtained by splitting 'cores' on comma. */
614 output_cores (struct ui_out *uiout, const char *field_name, const char *xcores)
616 struct cleanup *back_to = make_cleanup_ui_out_list_begin_end (uiout,
618 char *cores = xstrdup (xcores);
621 make_cleanup (xfree, cores);
623 for (p = strtok (p, ","); p; p = strtok (NULL, ","))
624 ui_out_field_string (uiout, NULL, p);
626 do_cleanups (back_to);
630 free_vector_of_ints (void *xvector)
632 VEC (int) **vector = xvector;
634 VEC_free (int, *vector);
638 do_nothing (splay_tree_key k)
643 free_vector_of_osdata_items (splay_tree_value xvalue)
645 VEC (osdata_item_s) *value = (VEC (osdata_item_s) *) xvalue;
647 /* We don't free the items itself, it will be done separately. */
648 VEC_free (osdata_item_s, value);
652 splay_tree_int_comparator (splay_tree_key xa, splay_tree_key xb)
661 free_splay_tree (void *xt)
664 splay_tree_delete (t);
668 list_available_thread_groups (VEC (int) *ids, int recurse)
671 struct osdata_item *item;
674 /* This keeps a map from integer (pid) to VEC (struct osdata_item *)*
675 The vector contains information about all threads for the given pid.
676 This is assigned an initial value to avoid "may be used uninitialized"
678 splay_tree tree = NULL;
680 /* get_osdata will throw if it cannot return data. */
681 data = get_osdata ("processes");
682 make_cleanup_osdata_free (data);
686 struct osdata *threads = get_osdata ("threads");
688 make_cleanup_osdata_free (threads);
689 tree = splay_tree_new (splay_tree_int_comparator,
691 free_vector_of_osdata_items);
692 make_cleanup (free_splay_tree, tree);
695 VEC_iterate (osdata_item_s, threads->items,
699 const char *pid = get_osdata_column (item, "pid");
700 int pid_i = strtoul (pid, NULL, 0);
701 VEC (osdata_item_s) *vec = 0;
703 splay_tree_node n = splay_tree_lookup (tree, pid_i);
706 VEC_safe_push (osdata_item_s, vec, item);
707 splay_tree_insert (tree, pid_i, (splay_tree_value)vec);
711 vec = (VEC (osdata_item_s) *) n->value;
712 VEC_safe_push (osdata_item_s, vec, item);
713 n->value = (splay_tree_value) vec;
718 make_cleanup_ui_out_list_begin_end (uiout, "groups");
721 VEC_iterate (osdata_item_s, data->items,
725 struct cleanup *back_to;
727 const char *pid = get_osdata_column (item, "pid");
728 const char *cmd = get_osdata_column (item, "command");
729 const char *user = get_osdata_column (item, "user");
730 const char *cores = get_osdata_column (item, "cores");
732 int pid_i = strtoul (pid, NULL, 0);
734 /* At present, the target will return all available processes
735 and if information about specific ones was required, we filter
736 undesired processes here. */
737 if (ids && bsearch (&pid_i, VEC_address (int, ids),
738 VEC_length (int, ids),
739 sizeof (int), compare_positive_ints) == NULL)
743 back_to = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
745 ui_out_field_fmt (uiout, "id", "%s", pid);
746 ui_out_field_string (uiout, "type", "process");
748 ui_out_field_string (uiout, "description", cmd);
750 ui_out_field_string (uiout, "user", user);
752 output_cores (uiout, "cores", cores);
756 splay_tree_node n = splay_tree_lookup (tree, pid_i);
759 VEC (osdata_item_s) *children = (VEC (osdata_item_s) *) n->value;
760 struct osdata_item *child;
763 make_cleanup_ui_out_list_begin_end (uiout, "threads");
766 VEC_iterate (osdata_item_s, children, ix_child, child);
769 struct cleanup *back_to_2 =
770 make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
771 const char *tid = get_osdata_column (child, "tid");
772 const char *tcore = get_osdata_column (child, "core");
774 ui_out_field_string (uiout, "id", tid);
776 ui_out_field_string (uiout, "core", tcore);
778 do_cleanups (back_to_2);
783 do_cleanups (back_to);
788 mi_cmd_list_thread_groups (char *command, char **argv, int argc)
790 struct cleanup *back_to;
797 AVAILABLE_OPT, RECURSE_OPT
799 static struct mi_opt opts[] =
801 {"-available", AVAILABLE_OPT, 0},
802 {"-recurse", RECURSE_OPT, 1},
811 int opt = mi_getopt ("-list-thread-groups", argc, argv, opts,
816 switch ((enum opt) opt)
822 if (strcmp (optarg, "0") == 0)
824 else if (strcmp (optarg, "1") == 0)
827 error (_("only '0' and '1' are valid values "
828 "for the '--recurse' option"));
833 for (; optind < argc; ++optind)
838 if (*(argv[optind]) != 'i')
839 error (_("invalid syntax of group id '%s'"), argv[optind]);
841 inf = strtoul (argv[optind] + 1, &end, 0);
844 error (_("invalid syntax of group id '%s'"), argv[optind]);
845 VEC_safe_push (int, ids, inf);
847 if (VEC_length (int, ids) > 1)
848 qsort (VEC_address (int, ids),
849 VEC_length (int, ids),
850 sizeof (int), compare_positive_ints);
852 back_to = make_cleanup (free_vector_of_ints, &ids);
856 list_available_thread_groups (ids, recurse);
858 else if (VEC_length (int, ids) == 1)
860 /* Local thread groups, single id. */
861 int id = *VEC_address (int, ids);
862 struct inferior *inf = find_inferior_id (id);
865 error (_("Non-existent thread group id '%d'"), id);
867 print_thread_info (uiout, NULL, inf->pid);
871 struct print_one_inferior_data data;
873 data.recurse = recurse;
874 data.inferiors = ids;
876 /* Local thread groups. Either no explicit ids -- and we
877 print everything, or several explicit ids. In both cases,
878 we print more than one group, and have to use 'groups'
879 as the top-level element. */
880 make_cleanup_ui_out_list_begin_end (uiout, "groups");
881 update_thread_list ();
882 iterate_over_inferiors (print_one_inferior, &data);
885 do_cleanups (back_to);
889 mi_cmd_data_list_register_names (char *command, char **argv, int argc)
891 struct gdbarch *gdbarch;
894 struct cleanup *cleanup;
896 /* Note that the test for a valid register must include checking the
897 gdbarch_register_name because gdbarch_num_regs may be allocated for
898 the union of the register sets within a family of related processors.
899 In this case, some entries of gdbarch_register_name will change depending
900 upon the particular processor being debugged. */
902 gdbarch = get_current_arch ();
903 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
905 cleanup = make_cleanup_ui_out_list_begin_end (uiout, "register-names");
907 if (argc == 0) /* No args, just do all the regs. */
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));
922 /* Else, list of register #s, just do listed regs. */
923 for (i = 0; i < argc; i++)
925 regnum = atoi (argv[i]);
926 if (regnum < 0 || regnum >= numregs)
927 error (_("bad register number"));
929 if (gdbarch_register_name (gdbarch, regnum) == NULL
930 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
931 ui_out_field_string (uiout, NULL, "");
933 ui_out_field_string (uiout, NULL,
934 gdbarch_register_name (gdbarch, regnum));
936 do_cleanups (cleanup);
940 mi_cmd_data_list_changed_registers (char *command, char **argv, int argc)
942 static struct regcache *this_regs = NULL;
943 struct regcache *prev_regs;
944 struct gdbarch *gdbarch;
945 int regnum, numregs, changed;
947 struct cleanup *cleanup;
949 /* The last time we visited this function, the current frame's register
950 contents were saved in THIS_REGS. Move THIS_REGS over to PREV_REGS,
951 and refresh THIS_REGS with the now-current register contents. */
953 prev_regs = this_regs;
954 this_regs = frame_save_as_regcache (get_selected_frame (NULL));
955 cleanup = make_cleanup_regcache_xfree (prev_regs);
957 /* Note that the test for a valid register must include checking the
958 gdbarch_register_name because gdbarch_num_regs may be allocated for
959 the union of the register sets within a family of related processors.
960 In this case, some entries of gdbarch_register_name will change depending
961 upon the particular processor being debugged. */
963 gdbarch = get_regcache_arch (this_regs);
964 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
966 make_cleanup_ui_out_list_begin_end (uiout, "changed-registers");
968 if (argc == 0) /* No args, just do all the regs. */
974 if (gdbarch_register_name (gdbarch, regnum) == NULL
975 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
977 changed = register_changed_p (regnum, prev_regs, this_regs);
979 error (_("-data-list-changed-registers: "
980 "Unable to read register contents."));
982 ui_out_field_int (uiout, NULL, regnum);
986 /* Else, list of register #s, just do listed regs. */
987 for (i = 0; i < argc; i++)
989 regnum = atoi (argv[i]);
993 && gdbarch_register_name (gdbarch, regnum) != NULL
994 && *gdbarch_register_name (gdbarch, regnum) != '\000')
996 changed = register_changed_p (regnum, prev_regs, this_regs);
998 error (_("-data-list-changed-registers: "
999 "Unable to read register contents."));
1001 ui_out_field_int (uiout, NULL, regnum);
1004 error (_("bad register number"));
1006 do_cleanups (cleanup);
1010 register_changed_p (int regnum, struct regcache *prev_regs,
1011 struct regcache *this_regs)
1013 struct gdbarch *gdbarch = get_regcache_arch (this_regs);
1014 gdb_byte prev_buffer[MAX_REGISTER_SIZE];
1015 gdb_byte this_buffer[MAX_REGISTER_SIZE];
1016 enum register_status prev_status;
1017 enum register_status this_status;
1019 /* First time through or after gdbarch change consider all registers
1021 if (!prev_regs || get_regcache_arch (prev_regs) != gdbarch)
1024 /* Get register contents and compare. */
1025 prev_status = regcache_cooked_read (prev_regs, regnum, prev_buffer);
1026 this_status = regcache_cooked_read (this_regs, regnum, this_buffer);
1028 if (this_status != prev_status)
1030 else if (this_status == REG_VALID)
1031 return memcmp (prev_buffer, this_buffer,
1032 register_size (gdbarch, regnum)) != 0;
1037 /* Return a list of register number and value pairs. The valid
1038 arguments expected are: a letter indicating the format in which to
1039 display the registers contents. This can be one of: x (hexadecimal), d
1040 (decimal), N (natural), t (binary), o (octal), r (raw). After the
1041 format argumetn there can be a sequence of numbers, indicating which
1042 registers to fetch the content of. If the format is the only argument,
1043 a list of all the registers with their values is returned. */
1045 mi_cmd_data_list_register_values (char *command, char **argv, int argc)
1047 struct frame_info *frame;
1048 struct gdbarch *gdbarch;
1049 int regnum, numregs, format;
1051 struct cleanup *list_cleanup, *tuple_cleanup;
1053 /* Note that the test for a valid register must include checking the
1054 gdbarch_register_name because gdbarch_num_regs may be allocated for
1055 the union of the register sets within a family of related processors.
1056 In this case, some entries of gdbarch_register_name will change depending
1057 upon the particular processor being debugged. */
1060 error (_("-data-list-register-values: Usage: "
1061 "-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);
1114 enum lval_type lval;
1115 static struct ui_stream *stb = NULL;
1118 stb = ui_out_stream_new (uiout);
1123 val = get_frame_register_value (frame, regnum);
1125 if (value_optimized_out (val))
1126 error (_("Optimized out"));
1131 char *ptr, buf[1024];
1132 const gdb_byte *valaddr = value_contents_for_printing (val);
1136 for (j = 0; j < register_size (gdbarch, regnum); j++)
1138 int idx = gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG ?
1139 j : register_size (gdbarch, regnum) - 1 - j;
1141 sprintf (ptr, "%02x", (unsigned char) valaddr[idx]);
1144 ui_out_field_string (uiout, "value", buf);
1145 /*fputs_filtered (buf, gdb_stdout); */
1149 struct value_print_options opts;
1151 get_formatted_print_options (&opts, format);
1153 val_print (value_type (val),
1154 value_contents_for_printing (val),
1155 value_embedded_offset (val), 0,
1156 stb->stream, 0, val, &opts, current_language);
1157 ui_out_field_stream (uiout, "value", stb);
1158 ui_out_stream_delete (stb);
1162 /* Write given values into registers. The registers and values are
1163 given as pairs. The corresponding MI command is
1164 -data-write-register-values <format>
1165 [<regnum1> <value1>...<regnumN> <valueN>] */
1167 mi_cmd_data_write_register_values (char *command, char **argv, int argc)
1169 struct regcache *regcache;
1170 struct gdbarch *gdbarch;
1174 /* Note that the test for a valid register must include checking the
1175 gdbarch_register_name because gdbarch_num_regs may be allocated for
1176 the union of the register sets within a family of related processors.
1177 In this case, some entries of gdbarch_register_name will change depending
1178 upon the particular processor being debugged. */
1180 regcache = get_current_regcache ();
1181 gdbarch = get_regcache_arch (regcache);
1182 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
1185 error (_("-data-write-register-values: Usage: -data-write-register-"
1186 "values <format> [<regnum1> <value1>...<regnumN> <valueN>]"));
1188 format = (int) argv[0][0];
1190 if (!target_has_registers)
1191 error (_("-data-write-register-values: No registers."));
1194 error (_("-data-write-register-values: No regs and values specified."));
1197 error (_("-data-write-register-values: "
1198 "Regs and vals are not in pairs."));
1200 for (i = 1; i < argc; i = i + 2)
1202 int regnum = atoi (argv[i]);
1204 if (regnum >= 0 && regnum < numregs
1205 && gdbarch_register_name (gdbarch, regnum)
1206 && *gdbarch_register_name (gdbarch, regnum))
1210 /* Get the value as a number. */
1211 value = parse_and_eval_address (argv[i + 1]);
1213 /* Write it down. */
1214 regcache_cooked_write_signed (regcache, regnum, value);
1217 error (_("bad register number"));
1221 /* Evaluate the value of the argument. The argument is an
1222 expression. If the expression contains spaces it needs to be
1223 included in double quotes. */
1225 mi_cmd_data_evaluate_expression (char *command, char **argv, int argc)
1227 struct expression *expr;
1228 struct cleanup *old_chain = NULL;
1230 struct ui_stream *stb = NULL;
1231 struct value_print_options opts;
1233 stb = ui_out_stream_new (uiout);
1237 ui_out_stream_delete (stb);
1238 error (_("-data-evaluate-expression: "
1239 "Usage: -data-evaluate-expression expression"));
1242 expr = parse_expression (argv[0]);
1244 old_chain = make_cleanup (free_current_contents, &expr);
1246 val = evaluate_expression (expr);
1248 /* Print the result of the expression evaluation. */
1249 get_user_print_options (&opts);
1251 common_val_print (val, stb->stream, 0, &opts, current_language);
1253 ui_out_field_stream (uiout, "value", stb);
1254 ui_out_stream_delete (stb);
1256 do_cleanups (old_chain);
1259 /* DATA-MEMORY-READ:
1261 ADDR: start address of data to be dumped.
1262 WORD-FORMAT: a char indicating format for the ``word''. See
1264 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
1265 NR_ROW: Number of rows.
1266 NR_COL: The number of colums (words per row).
1267 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
1268 ASCHAR for unprintable characters.
1270 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
1271 displayes them. Returns:
1273 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
1276 The number of bytes read is SIZE*ROW*COL. */
1279 mi_cmd_data_read_memory (char *command, char **argv, int argc)
1281 struct gdbarch *gdbarch = get_current_arch ();
1282 struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
1288 struct type *word_type;
1301 static struct mi_opt opts[] =
1303 {"o", OFFSET_OPT, 1},
1309 int opt = mi_getopt ("-data-read-memory", argc, argv, opts,
1314 switch ((enum opt) opt)
1317 offset = atol (optarg);
1324 if (argc < 5 || argc > 6)
1325 error (_("-data-read-memory: Usage: "
1326 "ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR]."));
1328 /* Extract all the arguments. */
1330 /* Start address of the memory dump. */
1331 addr = parse_and_eval_address (argv[0]) + offset;
1332 /* The format character to use when displaying a memory word. See
1333 the ``x'' command. */
1334 word_format = argv[1][0];
1335 /* The size of the memory word. */
1336 word_size = atol (argv[2]);
1340 word_type = builtin_type (gdbarch)->builtin_int8;
1344 word_type = builtin_type (gdbarch)->builtin_int16;
1348 word_type = builtin_type (gdbarch)->builtin_int32;
1352 word_type = builtin_type (gdbarch)->builtin_int64;
1356 word_type = builtin_type (gdbarch)->builtin_int8;
1359 /* The number of rows. */
1360 nr_rows = atol (argv[3]);
1362 error (_("-data-read-memory: invalid number of rows."));
1364 /* Number of bytes per row. */
1365 nr_cols = atol (argv[4]);
1367 error (_("-data-read-memory: invalid number of columns."));
1369 /* The un-printable character when printing ascii. */
1375 /* Create a buffer and read it in. */
1376 total_bytes = word_size * nr_rows * nr_cols;
1377 mbuf = xcalloc (total_bytes, 1);
1378 make_cleanup (xfree, mbuf);
1380 /* Dispatch memory reads to the topmost target, not the flattened
1382 nr_bytes = target_read (current_target.beneath,
1383 TARGET_OBJECT_MEMORY, NULL, mbuf,
1386 error (_("Unable to read memory."));
1388 /* Output the header information. */
1389 ui_out_field_core_addr (uiout, "addr", gdbarch, addr);
1390 ui_out_field_int (uiout, "nr-bytes", nr_bytes);
1391 ui_out_field_int (uiout, "total-bytes", total_bytes);
1392 ui_out_field_core_addr (uiout, "next-row",
1393 gdbarch, addr + word_size * nr_cols);
1394 ui_out_field_core_addr (uiout, "prev-row",
1395 gdbarch, addr - word_size * nr_cols);
1396 ui_out_field_core_addr (uiout, "next-page", gdbarch, addr + total_bytes);
1397 ui_out_field_core_addr (uiout, "prev-page", gdbarch, addr - total_bytes);
1399 /* Build the result as a two dimentional table. */
1401 struct ui_stream *stream = ui_out_stream_new (uiout);
1402 struct cleanup *cleanup_list_memory;
1406 cleanup_list_memory = make_cleanup_ui_out_list_begin_end (uiout, "memory");
1407 for (row = 0, row_byte = 0;
1409 row++, row_byte += nr_cols * word_size)
1413 struct cleanup *cleanup_tuple;
1414 struct cleanup *cleanup_list_data;
1415 struct value_print_options opts;
1417 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1418 ui_out_field_core_addr (uiout, "addr", gdbarch, addr + row_byte);
1419 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr +
1421 cleanup_list_data = make_cleanup_ui_out_list_begin_end (uiout, "data");
1422 get_formatted_print_options (&opts, word_format);
1423 for (col = 0, col_byte = row_byte;
1425 col++, col_byte += word_size)
1427 if (col_byte + word_size > nr_bytes)
1429 ui_out_field_string (uiout, NULL, "N/A");
1433 ui_file_rewind (stream->stream);
1434 print_scalar_formatted (mbuf + col_byte, word_type, &opts,
1435 word_asize, stream->stream);
1436 ui_out_field_stream (uiout, NULL, stream);
1439 do_cleanups (cleanup_list_data);
1444 ui_file_rewind (stream->stream);
1445 for (byte = row_byte;
1446 byte < row_byte + word_size * nr_cols; byte++)
1448 if (byte >= nr_bytes)
1450 fputc_unfiltered ('X', stream->stream);
1452 else if (mbuf[byte] < 32 || mbuf[byte] > 126)
1454 fputc_unfiltered (aschar, stream->stream);
1457 fputc_unfiltered (mbuf[byte], stream->stream);
1459 ui_out_field_stream (uiout, "ascii", stream);
1461 do_cleanups (cleanup_tuple);
1463 ui_out_stream_delete (stream);
1464 do_cleanups (cleanup_list_memory);
1466 do_cleanups (cleanups);
1470 mi_cmd_data_read_memory_bytes (char *command, char **argv, int argc)
1472 struct gdbarch *gdbarch = get_current_arch ();
1473 struct cleanup *cleanups;
1476 memory_read_result_s *read_result;
1478 VEC(memory_read_result_s) *result;
1486 static struct mi_opt opts[] =
1488 {"o", OFFSET_OPT, 1},
1494 int opt = mi_getopt ("-data-read-memory-bytes", argc, argv, opts,
1498 switch ((enum opt) opt)
1501 offset = atol (optarg);
1509 error (_("Usage: [ -o OFFSET ] ADDR LENGTH."));
1511 addr = parse_and_eval_address (argv[0]) + offset;
1512 length = atol (argv[1]);
1514 result = read_memory_robust (current_target.beneath, addr, length);
1516 cleanups = make_cleanup (free_memory_read_result_vector, result);
1518 if (VEC_length (memory_read_result_s, result) == 0)
1519 error (_("Unable to read memory."));
1521 make_cleanup_ui_out_list_begin_end (uiout, "memory");
1523 VEC_iterate (memory_read_result_s, result, ix, read_result);
1526 struct cleanup *t = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1530 ui_out_field_core_addr (uiout, "begin", gdbarch, read_result->begin);
1531 ui_out_field_core_addr (uiout, "offset", gdbarch, read_result->begin
1533 ui_out_field_core_addr (uiout, "end", gdbarch, read_result->end);
1535 data = xmalloc ((read_result->end - read_result->begin) * 2 + 1);
1537 for (i = 0, p = data;
1538 i < (read_result->end - read_result->begin);
1541 sprintf (p, "%02x", read_result->data[i]);
1543 ui_out_field_string (uiout, "contents", data);
1547 do_cleanups (cleanups);
1551 /* DATA-MEMORY-WRITE:
1553 COLUMN_OFFSET: optional argument. Must be preceeded by '-o'. The
1554 offset from the beginning of the memory grid row where the cell to
1556 ADDR: start address of the row in the memory grid where the memory
1557 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
1558 the location to write to.
1559 FORMAT: a char indicating format for the ``word''. See
1561 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
1562 VALUE: value to be written into the memory address.
1564 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1568 mi_cmd_data_write_memory (char *command, char **argv, int argc)
1570 struct gdbarch *gdbarch = get_current_arch ();
1571 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1575 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1576 enough when using a compiler other than GCC. */
1579 struct cleanup *old_chain;
1587 static struct mi_opt opts[] =
1589 {"o", OFFSET_OPT, 1},
1595 int opt = mi_getopt ("-data-write-memory", argc, argv, opts,
1600 switch ((enum opt) opt)
1603 offset = atol (optarg);
1611 error (_("-data-write-memory: Usage: "
1612 "[-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE."));
1614 /* Extract all the arguments. */
1615 /* Start address of the memory dump. */
1616 addr = parse_and_eval_address (argv[0]);
1617 /* The format character to use when displaying a memory word. See
1618 the ``x'' command. */
1619 word_format = argv[1][0];
1620 /* The size of the memory word. */
1621 word_size = atol (argv[2]);
1623 /* Calculate the real address of the write destination. */
1624 addr += (offset * word_size);
1626 /* Get the value as a number. */
1627 value = parse_and_eval_address (argv[3]);
1628 /* Get the value into an array. */
1629 buffer = xmalloc (word_size);
1630 old_chain = make_cleanup (xfree, buffer);
1631 store_signed_integer (buffer, word_size, byte_order, value);
1632 /* Write it down to memory. */
1633 write_memory (addr, buffer, word_size);
1634 /* Free the buffer. */
1635 do_cleanups (old_chain);
1638 /* DATA-MEMORY-WRITE-RAW:
1641 DATA: string of bytes to write at that address. */
1643 mi_cmd_data_write_memory_bytes (char *command, char **argv, int argc)
1649 struct cleanup *back_to;
1652 error (_("Usage: ADDR DATA."));
1654 addr = parse_and_eval_address (argv[0]);
1656 len = strlen (cdata)/2;
1658 data = xmalloc (len);
1659 back_to = make_cleanup (xfree, data);
1661 for (i = 0; i < len; ++i)
1664 sscanf (cdata + i * 2, "%02x", &x);
1665 data[i] = (gdb_byte)x;
1668 r = target_write_memory (addr, data, len);
1670 error (_("Could not write memory"));
1672 do_cleanups (back_to);
1677 mi_cmd_enable_timings (char *command, char **argv, int argc)
1683 if (strcmp (argv[0], "yes") == 0)
1685 else if (strcmp (argv[0], "no") == 0)
1696 error (_("-enable-timings: Usage: %s {yes|no}"), command);
1700 mi_cmd_list_features (char *command, char **argv, int argc)
1704 struct cleanup *cleanup = NULL;
1706 cleanup = make_cleanup_ui_out_list_begin_end (uiout, "features");
1707 ui_out_field_string (uiout, NULL, "frozen-varobjs");
1708 ui_out_field_string (uiout, NULL, "pending-breakpoints");
1709 ui_out_field_string (uiout, NULL, "thread-info");
1710 ui_out_field_string (uiout, NULL, "data-read-memory-bytes");
1713 ui_out_field_string (uiout, NULL, "python");
1716 do_cleanups (cleanup);
1720 error (_("-list-features should be passed no arguments"));
1724 mi_cmd_list_target_features (char *command, char **argv, int argc)
1728 struct cleanup *cleanup = NULL;
1730 cleanup = make_cleanup_ui_out_list_begin_end (uiout, "features");
1731 if (target_can_async_p ())
1732 ui_out_field_string (uiout, NULL, "async");
1733 if (target_can_execute_reverse)
1734 ui_out_field_string (uiout, NULL, "reverse");
1736 do_cleanups (cleanup);
1740 error (_("-list-target-features should be passed no arguments"));
1744 mi_cmd_add_inferior (char *command, char **argv, int argc)
1746 struct inferior *inf;
1749 error (_("-add-inferior should be passed no arguments"));
1751 inf = add_inferior_with_spaces ();
1753 ui_out_field_fmt (uiout, "inferior", "i%d", inf->num);
1756 /* Callback used to find the first inferior other than the
1760 get_other_inferior (struct inferior *inf, void *arg)
1762 if (inf == current_inferior ())
1769 mi_cmd_remove_inferior (char *command, char **argv, int argc)
1772 struct inferior *inf;
1775 error (_("-remove-inferior should be passed a single argument"));
1777 if (sscanf (argv[0], "i%d", &id) != 1)
1778 error (_("the thread group id is syntactically invalid"));
1780 inf = find_inferior_id (id);
1782 error (_("the specified thread group does not exist"));
1785 error (_("cannot remove an active inferior"));
1787 if (inf == current_inferior ())
1789 struct thread_info *tp = 0;
1790 struct inferior *new_inferior
1791 = iterate_over_inferiors (get_other_inferior, NULL);
1793 if (new_inferior == NULL)
1794 error (_("Cannot remove last inferior"));
1796 set_current_inferior (new_inferior);
1797 if (new_inferior->pid != 0)
1798 tp = any_thread_of_process (new_inferior->pid);
1799 switch_to_thread (tp ? tp->ptid : null_ptid);
1800 set_current_program_space (new_inferior->pspace);
1803 delete_inferior_1 (inf, 1 /* silent */);
1808 /* Execute a command within a safe environment.
1809 Return <0 for error; >=0 for ok.
1811 args->action will tell mi_execute_command what action
1812 to perfrom after the given command has executed (display/suppress
1813 prompt, display error). */
1816 captured_mi_execute_command (struct ui_out *uiout, struct mi_parse *context)
1818 struct cleanup *cleanup;
1821 current_command_ts = context->cmd_start;
1823 current_token = xstrdup (context->token);
1824 cleanup = make_cleanup (free_current_contents, ¤t_token);
1826 running_result_record_printed = 0;
1828 switch (context->op)
1831 /* A MI command was read from the input stream. */
1833 /* FIXME: gdb_???? */
1834 fprintf_unfiltered (raw_stdout, " token=`%s' command=`%s' args=`%s'\n",
1835 context->token, context->command, context->args);
1838 mi_cmd_execute (context);
1840 /* Print the result if there were no errors.
1842 Remember that on the way out of executing a command, you have
1843 to directly use the mi_interp's uiout, since the command could
1844 have reset the interpreter, in which case the current uiout
1845 will most likely crash in the mi_out_* routines. */
1846 if (!running_result_record_printed)
1848 fputs_unfiltered (context->token, raw_stdout);
1849 /* There's no particularly good reason why target-connect results
1850 in not ^done. Should kill ^connected for MI3. */
1851 fputs_unfiltered (strcmp (context->command, "target-select") == 0
1852 ? "^connected" : "^done", raw_stdout);
1853 mi_out_put (uiout, raw_stdout);
1854 mi_out_rewind (uiout);
1855 mi_print_timing_maybe ();
1856 fputs_unfiltered ("\n", raw_stdout);
1859 /* The command does not want anything to be printed. In that
1860 case, the command probably should not have written anything
1861 to uiout, but in case it has written something, discard it. */
1862 mi_out_rewind (uiout);
1869 /* A CLI command was read from the input stream. */
1870 /* This "feature" will be removed as soon as we have a
1871 complete set of mi commands. */
1872 /* Echo the command on the console. */
1873 fprintf_unfiltered (gdb_stdlog, "%s\n", context->command);
1874 /* Call the "console" interpreter. */
1875 argv[0] = "console";
1876 argv[1] = context->command;
1877 mi_cmd_interpreter_exec ("-interpreter-exec", argv, 2);
1879 /* If we changed interpreters, DON'T print out anything. */
1880 if (current_interp_named_p (INTERP_MI)
1881 || current_interp_named_p (INTERP_MI1)
1882 || current_interp_named_p (INTERP_MI2)
1883 || current_interp_named_p (INTERP_MI3))
1885 if (!running_result_record_printed)
1887 fputs_unfiltered (context->token, raw_stdout);
1888 fputs_unfiltered ("^done", raw_stdout);
1889 mi_out_put (uiout, raw_stdout);
1890 mi_out_rewind (uiout);
1891 mi_print_timing_maybe ();
1892 fputs_unfiltered ("\n", raw_stdout);
1895 mi_out_rewind (uiout);
1902 do_cleanups (cleanup);
1907 /* Print a gdb exception to the MI output stream. */
1910 mi_print_exception (const char *token, struct gdb_exception exception)
1912 fputs_unfiltered (token, raw_stdout);
1913 fputs_unfiltered ("^error,msg=\"", raw_stdout);
1914 if (exception.message == NULL)
1915 fputs_unfiltered ("unknown error", raw_stdout);
1917 fputstr_unfiltered (exception.message, '"', raw_stdout);
1918 fputs_unfiltered ("\"\n", raw_stdout);
1922 mi_execute_command (char *cmd, int from_tty)
1925 struct mi_parse *command = NULL;
1926 volatile struct gdb_exception exception;
1928 /* This is to handle EOF (^D). We just quit gdb. */
1929 /* FIXME: we should call some API function here. */
1931 quit_force (NULL, from_tty);
1933 target_log_command (cmd);
1935 TRY_CATCH (exception, RETURN_MASK_ALL)
1937 command = mi_parse (cmd, &token);
1939 if (exception.reason < 0)
1941 mi_print_exception (token, exception);
1946 volatile struct gdb_exception result;
1947 ptid_t previous_ptid = inferior_ptid;
1949 command->token = token;
1953 command->cmd_start = (struct mi_timestamp *)
1954 xmalloc (sizeof (struct mi_timestamp));
1955 timestamp (command->cmd_start);
1958 TRY_CATCH (result, RETURN_MASK_ALL)
1960 captured_mi_execute_command (uiout, command);
1962 if (result.reason < 0)
1964 /* The command execution failed and error() was called
1966 mi_print_exception (command->token, result);
1967 mi_out_rewind (uiout);
1970 bpstat_do_actions ();
1972 if (/* The notifications are only output when the top-level
1973 interpreter (specified on the command line) is MI. */
1974 ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ()))
1975 /* Don't try report anything if there are no threads --
1976 the program is dead. */
1977 && thread_count () != 0
1978 /* -thread-select explicitly changes thread. If frontend uses that
1979 internally, we don't want to emit =thread-selected, since
1980 =thread-selected is supposed to indicate user's intentions. */
1981 && strcmp (command->command, "thread-select") != 0)
1983 struct mi_interp *mi = top_level_interpreter_data ();
1984 int report_change = 0;
1986 if (command->thread == -1)
1988 report_change = (!ptid_equal (previous_ptid, null_ptid)
1989 && !ptid_equal (inferior_ptid, previous_ptid)
1990 && !ptid_equal (inferior_ptid, null_ptid));
1992 else if (!ptid_equal (inferior_ptid, null_ptid))
1994 struct thread_info *ti = inferior_thread ();
1996 report_change = (ti->num != command->thread);
2001 struct thread_info *ti = inferior_thread ();
2003 target_terminal_ours ();
2004 fprintf_unfiltered (mi->event_channel,
2005 "thread-selected,id=\"%d\"",
2007 gdb_flush (mi->event_channel);
2011 mi_parse_free (command);
2014 fputs_unfiltered ("(gdb) \n", raw_stdout);
2015 gdb_flush (raw_stdout);
2016 /* Print any buffered hook code. */
2021 mi_cmd_execute (struct mi_parse *parse)
2023 struct cleanup *cleanup;
2025 cleanup = prepare_execute_command ();
2027 if (parse->all && parse->thread_group != -1)
2028 error (_("Cannot specify --thread-group together with --all"));
2030 if (parse->all && parse->thread != -1)
2031 error (_("Cannot specify --thread together with --all"));
2033 if (parse->thread_group != -1 && parse->thread != -1)
2034 error (_("Cannot specify --thread together with --thread-group"));
2036 if (parse->frame != -1 && parse->thread == -1)
2037 error (_("Cannot specify --frame without --thread"));
2039 if (parse->thread_group != -1)
2041 struct inferior *inf = find_inferior_id (parse->thread_group);
2042 struct thread_info *tp = 0;
2045 error (_("Invalid thread group for the --thread-group option"));
2047 set_current_inferior (inf);
2048 /* This behaviour means that if --thread-group option identifies
2049 an inferior with multiple threads, then a random one will be picked.
2050 This is not a problem -- frontend should always provide --thread if
2051 it wishes to operate on a specific thread. */
2053 tp = any_thread_of_process (inf->pid);
2054 switch_to_thread (tp ? tp->ptid : null_ptid);
2055 set_current_program_space (inf->pspace);
2058 if (parse->thread != -1)
2060 struct thread_info *tp = find_thread_id (parse->thread);
2063 error (_("Invalid thread id: %d"), parse->thread);
2065 if (is_exited (tp->ptid))
2066 error (_("Thread id: %d has terminated"), parse->thread);
2068 switch_to_thread (tp->ptid);
2071 if (parse->frame != -1)
2073 struct frame_info *fid;
2074 int frame = parse->frame;
2076 fid = find_relative_frame (get_current_frame (), &frame);
2078 /* find_relative_frame was successful */
2081 error (_("Invalid frame id: %d"), frame);
2084 current_context = parse;
2086 if (strncmp (parse->command, "break-", sizeof ("break-") - 1 ) == 0)
2088 make_cleanup_restore_integer (&mi_suppress_breakpoint_notifications);
2089 mi_suppress_breakpoint_notifications = 1;
2092 if (parse->cmd->argv_func != NULL)
2094 parse->cmd->argv_func (parse->command, parse->argv, parse->argc);
2096 else if (parse->cmd->cli.cmd != 0)
2098 /* FIXME: DELETE THIS. */
2099 /* The operation is still implemented by a cli command. */
2100 /* Must be a synchronous one. */
2101 mi_execute_cli_command (parse->cmd->cli.cmd, parse->cmd->cli.args_p,
2106 /* FIXME: DELETE THIS. */
2107 struct ui_file *stb;
2109 stb = mem_fileopen ();
2111 fputs_unfiltered ("Undefined mi command: ", stb);
2112 fputstr_unfiltered (parse->command, '"', stb);
2113 fputs_unfiltered (" (missing implementation)", stb);
2115 make_cleanup_ui_file_delete (stb);
2118 do_cleanups (cleanup);
2121 /* FIXME: This is just a hack so we can get some extra commands going.
2122 We don't want to channel things through the CLI, but call libgdb directly.
2123 Use only for synchronous commands. */
2126 mi_execute_cli_command (const char *cmd, int args_p, const char *args)
2130 struct cleanup *old_cleanups;
2134 run = xstrprintf ("%s %s", cmd, args);
2136 run = xstrdup (cmd);
2138 /* FIXME: gdb_???? */
2139 fprintf_unfiltered (gdb_stdout, "cli=%s run=%s\n",
2141 old_cleanups = make_cleanup (xfree, run);
2142 execute_command ( /*ui */ run, 0 /*from_tty */ );
2143 do_cleanups (old_cleanups);
2149 mi_execute_async_cli_command (char *cli_command, char **argv, int argc)
2151 struct cleanup *old_cleanups;
2154 if (target_can_async_p ())
2155 run = xstrprintf ("%s %s&", cli_command, argc ? *argv : "");
2157 run = xstrprintf ("%s %s", cli_command, argc ? *argv : "");
2158 old_cleanups = make_cleanup (xfree, run);
2160 execute_command ( /*ui */ run, 0 /*from_tty */ );
2162 /* Do this before doing any printing. It would appear that some
2163 print code leaves garbage around in the buffer. */
2164 do_cleanups (old_cleanups);
2168 mi_load_progress (const char *section_name,
2169 unsigned long sent_so_far,
2170 unsigned long total_section,
2171 unsigned long total_sent,
2172 unsigned long grand_total)
2174 struct timeval time_now, delta, update_threshold;
2175 static struct timeval last_update;
2176 static char *previous_sect_name = NULL;
2178 struct ui_out *saved_uiout;
2180 /* This function is called through deprecated_show_load_progress
2181 which means uiout may not be correct. Fix it for the duration
2182 of this function. */
2183 saved_uiout = uiout;
2185 if (current_interp_named_p (INTERP_MI)
2186 || current_interp_named_p (INTERP_MI2))
2187 uiout = mi_out_new (2);
2188 else if (current_interp_named_p (INTERP_MI1))
2189 uiout = mi_out_new (1);
2190 else if (current_interp_named_p (INTERP_MI3))
2191 uiout = mi_out_new (3);
2195 update_threshold.tv_sec = 0;
2196 update_threshold.tv_usec = 500000;
2197 gettimeofday (&time_now, NULL);
2199 delta.tv_usec = time_now.tv_usec - last_update.tv_usec;
2200 delta.tv_sec = time_now.tv_sec - last_update.tv_sec;
2202 if (delta.tv_usec < 0)
2205 delta.tv_usec += 1000000L;
2208 new_section = (previous_sect_name ?
2209 strcmp (previous_sect_name, section_name) : 1);
2212 struct cleanup *cleanup_tuple;
2214 xfree (previous_sect_name);
2215 previous_sect_name = xstrdup (section_name);
2218 fputs_unfiltered (current_token, raw_stdout);
2219 fputs_unfiltered ("+download", raw_stdout);
2220 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
2221 ui_out_field_string (uiout, "section", section_name);
2222 ui_out_field_int (uiout, "section-size", total_section);
2223 ui_out_field_int (uiout, "total-size", grand_total);
2224 do_cleanups (cleanup_tuple);
2225 mi_out_put (uiout, raw_stdout);
2226 fputs_unfiltered ("\n", raw_stdout);
2227 gdb_flush (raw_stdout);
2230 if (delta.tv_sec >= update_threshold.tv_sec &&
2231 delta.tv_usec >= update_threshold.tv_usec)
2233 struct cleanup *cleanup_tuple;
2235 last_update.tv_sec = time_now.tv_sec;
2236 last_update.tv_usec = time_now.tv_usec;
2238 fputs_unfiltered (current_token, raw_stdout);
2239 fputs_unfiltered ("+download", raw_stdout);
2240 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
2241 ui_out_field_string (uiout, "section", section_name);
2242 ui_out_field_int (uiout, "section-sent", sent_so_far);
2243 ui_out_field_int (uiout, "section-size", total_section);
2244 ui_out_field_int (uiout, "total-sent", total_sent);
2245 ui_out_field_int (uiout, "total-size", grand_total);
2246 do_cleanups (cleanup_tuple);
2247 mi_out_put (uiout, raw_stdout);
2248 fputs_unfiltered ("\n", raw_stdout);
2249 gdb_flush (raw_stdout);
2253 uiout = saved_uiout;
2257 timestamp (struct mi_timestamp *tv)
2259 gettimeofday (&tv->wallclock, NULL);
2260 #ifdef HAVE_GETRUSAGE
2261 getrusage (RUSAGE_SELF, &rusage);
2262 tv->utime.tv_sec = rusage.ru_utime.tv_sec;
2263 tv->utime.tv_usec = rusage.ru_utime.tv_usec;
2264 tv->stime.tv_sec = rusage.ru_stime.tv_sec;
2265 tv->stime.tv_usec = rusage.ru_stime.tv_usec;
2268 long usec = get_run_time ();
2270 tv->utime.tv_sec = usec/1000000L;
2271 tv->utime.tv_usec = usec - 1000000L*tv->utime.tv_sec;
2272 tv->stime.tv_sec = 0;
2273 tv->stime.tv_usec = 0;
2279 print_diff_now (struct mi_timestamp *start)
2281 struct mi_timestamp now;
2284 print_diff (start, &now);
2288 mi_print_timing_maybe (void)
2290 /* If the command is -enable-timing then do_timings may be
2291 true whilst current_command_ts is not initialized. */
2292 if (do_timings && current_command_ts)
2293 print_diff_now (current_command_ts);
2297 timeval_diff (struct timeval start, struct timeval end)
2299 return ((end.tv_sec - start.tv_sec) * 1000000L)
2300 + (end.tv_usec - start.tv_usec);
2304 print_diff (struct mi_timestamp *start, struct mi_timestamp *end)
2308 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
2309 timeval_diff (start->wallclock, end->wallclock) / 1000000.0,
2310 timeval_diff (start->utime, end->utime) / 1000000.0,
2311 timeval_diff (start->stime, end->stime) / 1000000.0);
2315 mi_cmd_trace_define_variable (char *command, char **argv, int argc)
2317 struct expression *expr;
2318 struct cleanup *back_to;
2319 LONGEST initval = 0;
2320 struct trace_state_variable *tsv;
2323 if (argc != 1 && argc != 2)
2324 error (_("Usage: -trace-define-variable VARIABLE [VALUE]"));
2326 expr = parse_expression (argv[0]);
2327 back_to = make_cleanup (xfree, expr);
2329 if (expr->nelts == 3 && expr->elts[0].opcode == OP_INTERNALVAR)
2331 struct internalvar *intvar = expr->elts[1].internalvar;
2334 name = internalvar_name (intvar);
2337 if (!name || *name == '\0')
2338 error (_("Invalid name of trace variable"));
2340 tsv = find_trace_state_variable (name);
2342 tsv = create_trace_state_variable (name);
2345 initval = value_as_long (parse_and_eval (argv[1]));
2347 tsv->initial_value = initval;
2349 do_cleanups (back_to);
2353 mi_cmd_trace_list_variables (char *command, char **argv, int argc)
2356 error (_("-trace-list-variables: no arguments are allowed"));
2358 tvariables_info_1 ();
2362 mi_cmd_trace_find (char *command, char **argv, int argc)
2367 error (_("trace selection mode is required"));
2371 if (strcmp (mode, "none") == 0)
2373 tfind_1 (tfind_number, -1, 0, 0, 0);
2377 if (current_trace_status ()->running)
2378 error (_("May not look at trace frames while trace is running."));
2380 if (strcmp (mode, "frame-number") == 0)
2383 error (_("frame number is required"));
2384 tfind_1 (tfind_number, atoi (argv[1]), 0, 0, 0);
2386 else if (strcmp (mode, "tracepoint-number") == 0)
2389 error (_("tracepoint number is required"));
2390 tfind_1 (tfind_tp, atoi (argv[1]), 0, 0, 0);
2392 else if (strcmp (mode, "pc") == 0)
2395 error (_("PC is required"));
2396 tfind_1 (tfind_pc, 0, parse_and_eval_address (argv[1]), 0, 0);
2398 else if (strcmp (mode, "pc-inside-range") == 0)
2401 error (_("Start and end PC are required"));
2402 tfind_1 (tfind_range, 0, parse_and_eval_address (argv[1]),
2403 parse_and_eval_address (argv[2]), 0);
2405 else if (strcmp (mode, "pc-outside-range") == 0)
2408 error (_("Start and end PC are required"));
2409 tfind_1 (tfind_outside, 0, parse_and_eval_address (argv[1]),
2410 parse_and_eval_address (argv[2]), 0);
2412 else if (strcmp (mode, "line") == 0)
2414 struct symtabs_and_lines sals;
2415 struct symtab_and_line sal;
2416 static CORE_ADDR start_pc, end_pc;
2417 struct cleanup *back_to;
2420 error (_("Line is required"));
2422 sals = decode_line_spec (argv[1], 1);
2423 back_to = make_cleanup (xfree, sals.sals);
2427 if (sal.symtab == 0)
2428 error (_("Could not find the specified line"));
2430 if (sal.line > 0 && find_line_pc_range (sal, &start_pc, &end_pc))
2431 tfind_1 (tfind_range, 0, start_pc, end_pc - 1, 0);
2433 error (_("Could not find the specified line"));
2435 do_cleanups (back_to);
2438 error (_("Invalid mode '%s'"), mode);
2440 if (has_stack_frames () || get_traceframe_number () >= 0)
2442 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
2447 mi_cmd_trace_save (char *command, char **argv, int argc)
2449 int target_saves = 0;
2452 if (argc != 1 && argc != 2)
2453 error (_("Usage: -trace-save [-r] filename"));
2458 if (strcmp (argv[0], "-r") == 0)
2461 error (_("Invalid option: %s"), argv[0]);
2468 trace_save (filename, target_saves);
2473 mi_cmd_trace_start (char *command, char **argv, int argc)
2479 mi_cmd_trace_status (char *command, char **argv, int argc)
2481 trace_status_mi (0);
2485 mi_cmd_trace_stop (char *command, char **argv, int argc)
2488 trace_status_mi (1);