3 Copyright (C) 2000-2014 Free Software Foundation, Inc.
5 Contributed by Cygnus Solutions (a Red Hat company).
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "arch-utils.h"
28 #include "exceptions.h"
30 #include "gdbthread.h"
33 #include "mi-getopt.h"
34 #include "mi-console.h"
38 #include "event-loop.h"
39 #include "event-top.h"
40 #include "gdbcore.h" /* For write_memory(). */
46 #include "mi-common.h"
51 #include "splay-tree.h"
52 #include "tracepoint.h"
56 #include "extension.h"
62 #if defined HAVE_SYS_RESOURCE_H
63 #include <sys/resource.h>
77 struct ui_file *raw_stdout;
79 /* This is used to pass the current command timestamp down to
80 continuation routines. */
81 static struct mi_timestamp *current_command_ts;
83 static int do_timings = 0;
86 /* Few commands would like to know if options like --thread-group were
87 explicitly specified. This variable keeps the current parsed
88 command including all option, and make it possible. */
89 static struct mi_parse *current_context;
91 int running_result_record_printed = 1;
93 /* Flag indicating that the target has proceeded since the last
94 command was issued. */
97 extern void _initialize_mi_main (void);
98 static void mi_cmd_execute (struct mi_parse *parse);
100 static void mi_execute_cli_command (const char *cmd, int args_p,
102 static void mi_execute_async_cli_command (char *cli_command,
103 char **argv, int argc);
104 static int register_changed_p (int regnum, struct regcache *,
106 static void output_register (struct frame_info *, int regnum, int format,
107 int skip_unavailable);
109 /* Controls whether the frontend wants MI in async mode. */
110 static int mi_async = 0;
112 /* The set command writes to this variable. If the inferior is
113 executing, mi_async is *not* updated. */
114 static int mi_async_1 = 0;
117 set_mi_async_command (char *args, int from_tty,
118 struct cmd_list_element *c)
120 if (have_live_inferiors ())
122 mi_async_1 = mi_async;
123 error (_("Cannot change this setting while the inferior is running."));
126 mi_async = mi_async_1;
130 show_mi_async_command (struct ui_file *file, int from_tty,
131 struct cmd_list_element *c,
134 fprintf_filtered (file,
135 _("Whether MI is in asynchronous mode is %s.\n"),
139 /* A wrapper for target_can_async_p that takes the MI setting into
145 return mi_async && target_can_async_p ();
148 /* Command implementations. FIXME: Is this libgdb? No. This is the MI
149 layer that calls libgdb. Any operation used in the below should be
152 static void timestamp (struct mi_timestamp *tv);
154 static void print_diff_now (struct mi_timestamp *start);
155 static void print_diff (struct mi_timestamp *start, struct mi_timestamp *end);
158 mi_cmd_gdb_exit (char *command, char **argv, int argc)
160 /* We have to print everything right here because we never return. */
162 fputs_unfiltered (current_token, raw_stdout);
163 fputs_unfiltered ("^exit\n", raw_stdout);
164 mi_out_put (current_uiout, raw_stdout);
165 gdb_flush (raw_stdout);
166 /* FIXME: The function called is not yet a formal libgdb function. */
167 quit_force (NULL, FROM_TTY);
171 mi_cmd_exec_next (char *command, char **argv, int argc)
173 /* FIXME: Should call a libgdb function, not a cli wrapper. */
174 if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
175 mi_execute_async_cli_command ("reverse-next", argv + 1, argc - 1);
177 mi_execute_async_cli_command ("next", argv, argc);
181 mi_cmd_exec_next_instruction (char *command, char **argv, int argc)
183 /* FIXME: Should call a libgdb function, not a cli wrapper. */
184 if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
185 mi_execute_async_cli_command ("reverse-nexti", argv + 1, argc - 1);
187 mi_execute_async_cli_command ("nexti", argv, argc);
191 mi_cmd_exec_step (char *command, char **argv, int argc)
193 /* FIXME: Should call a libgdb function, not a cli wrapper. */
194 if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
195 mi_execute_async_cli_command ("reverse-step", argv + 1, argc - 1);
197 mi_execute_async_cli_command ("step", argv, argc);
201 mi_cmd_exec_step_instruction (char *command, char **argv, int argc)
203 /* FIXME: Should call a libgdb function, not a cli wrapper. */
204 if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
205 mi_execute_async_cli_command ("reverse-stepi", argv + 1, argc - 1);
207 mi_execute_async_cli_command ("stepi", argv, argc);
211 mi_cmd_exec_finish (char *command, char **argv, int argc)
213 /* FIXME: Should call a libgdb function, not a cli wrapper. */
214 if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
215 mi_execute_async_cli_command ("reverse-finish", argv + 1, argc - 1);
217 mi_execute_async_cli_command ("finish", argv, argc);
221 mi_cmd_exec_return (char *command, char **argv, int argc)
223 /* This command doesn't really execute the target, it just pops the
224 specified number of frames. */
226 /* Call return_command with from_tty argument equal to 0 so as to
227 avoid being queried. */
228 return_command (*argv, 0);
230 /* Call return_command with from_tty argument equal to 0 so as to
231 avoid being queried. */
232 return_command (NULL, 0);
234 /* Because we have called return_command with from_tty = 0, we need
235 to print the frame here. */
236 print_stack_frame (get_selected_frame (NULL), 1, LOC_AND_ADDRESS, 1);
240 mi_cmd_exec_jump (char *args, char **argv, int argc)
242 /* FIXME: Should call a libgdb function, not a cli wrapper. */
243 mi_execute_async_cli_command ("jump", argv, argc);
247 proceed_thread (struct thread_info *thread, int pid)
249 if (!is_stopped (thread->ptid))
252 if (pid != 0 && ptid_get_pid (thread->ptid) != pid)
255 switch_to_thread (thread->ptid);
256 clear_proceed_status ();
257 proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT, 0);
261 proceed_thread_callback (struct thread_info *thread, void *arg)
263 int pid = *(int *)arg;
265 proceed_thread (thread, pid);
270 exec_continue (char **argv, int argc)
272 prepare_execution_command (¤t_target, mi_async_p ());
276 /* In non-stop mode, 'resume' always resumes a single thread.
277 Therefore, to resume all threads of the current inferior, or
278 all threads in all inferiors, we need to iterate over
281 See comment on infcmd.c:proceed_thread_callback for rationale. */
282 if (current_context->all || current_context->thread_group != -1)
285 struct cleanup *back_to = make_cleanup_restore_current_thread ();
287 if (!current_context->all)
290 = find_inferior_id (current_context->thread_group);
294 iterate_over_threads (proceed_thread_callback, &pid);
295 do_cleanups (back_to);
304 struct cleanup *back_to = make_cleanup_restore_integer (&sched_multi);
306 if (current_context->all)
313 /* In all-stop mode, -exec-continue traditionally resumed
314 either all threads, or one thread, depending on the
315 'scheduler-locking' variable. Let's continue to do the
319 do_cleanups (back_to);
324 exec_direction_forward (void *notused)
326 execution_direction = EXEC_FORWARD;
330 exec_reverse_continue (char **argv, int argc)
332 enum exec_direction_kind dir = execution_direction;
333 struct cleanup *old_chain;
335 if (dir == EXEC_REVERSE)
336 error (_("Already in reverse mode."));
338 if (!target_can_execute_reverse)
339 error (_("Target %s does not support this command."), target_shortname);
341 old_chain = make_cleanup (exec_direction_forward, NULL);
342 execution_direction = EXEC_REVERSE;
343 exec_continue (argv, argc);
344 do_cleanups (old_chain);
348 mi_cmd_exec_continue (char *command, char **argv, int argc)
350 if (argc > 0 && strcmp (argv[0], "--reverse") == 0)
351 exec_reverse_continue (argv + 1, argc - 1);
353 exec_continue (argv, argc);
357 interrupt_thread_callback (struct thread_info *thread, void *arg)
359 int pid = *(int *)arg;
361 if (!is_running (thread->ptid))
364 if (ptid_get_pid (thread->ptid) != pid)
367 target_stop (thread->ptid);
371 /* Interrupt the execution of the target. Note how we must play
372 around with the token variables, in order to display the current
373 token in the result of the interrupt command, and the previous
374 execution token when the target finally stops. See comments in
378 mi_cmd_exec_interrupt (char *command, char **argv, int argc)
380 /* In all-stop mode, everything stops, so we don't need to try
381 anything specific. */
384 interrupt_target_1 (0);
388 if (current_context->all)
390 /* This will interrupt all threads in all inferiors. */
391 interrupt_target_1 (1);
393 else if (current_context->thread_group != -1)
395 struct inferior *inf = find_inferior_id (current_context->thread_group);
397 iterate_over_threads (interrupt_thread_callback, &inf->pid);
401 /* Interrupt just the current thread -- either explicitly
402 specified via --thread or whatever was current before
403 MI command was sent. */
404 interrupt_target_1 (0);
408 /* Callback for iterate_over_inferiors which starts the execution
409 of the given inferior.
411 ARG is a pointer to an integer whose value, if non-zero, indicates
412 that the program should be stopped when reaching the main subprogram
413 (similar to what the CLI "start" command does). */
416 run_one_inferior (struct inferior *inf, void *arg)
418 int start_p = *(int *) arg;
419 const char *run_cmd = start_p ? "start" : "run";
423 if (inf->pid != ptid_get_pid (inferior_ptid))
425 struct thread_info *tp;
427 tp = any_thread_of_process (inf->pid);
429 error (_("Inferior has no threads."));
431 switch_to_thread (tp->ptid);
436 set_current_inferior (inf);
437 switch_to_thread (null_ptid);
438 set_current_program_space (inf->pspace);
440 mi_execute_cli_command (run_cmd, mi_async_p (),
441 mi_async_p () ? "&" : NULL);
446 mi_cmd_exec_run (char *command, char **argv, int argc)
451 /* Parse the command options. */
456 static const struct mi_opt opts[] =
458 {"-start", START_OPT, 0},
467 int opt = mi_getopt ("-exec-run", argc, argv, opts, &oind, &oarg);
471 switch ((enum opt) opt)
479 /* This command does not accept any argument. Make sure the user
480 did not provide any. */
482 error (_("Invalid argument: %s"), argv[oind]);
484 if (current_context->all)
486 struct cleanup *back_to = save_current_space_and_thread ();
488 iterate_over_inferiors (run_one_inferior, &start_p);
489 do_cleanups (back_to);
493 const char *run_cmd = start_p ? "start" : "run";
495 mi_execute_cli_command (run_cmd, mi_async_p (),
496 mi_async_p () ? "&" : NULL);
502 find_thread_of_process (struct thread_info *ti, void *p)
506 if (ptid_get_pid (ti->ptid) == pid && !is_exited (ti->ptid))
513 mi_cmd_target_detach (char *command, char **argv, int argc)
515 if (argc != 0 && argc != 1)
516 error (_("Usage: -target-detach [pid | thread-group]"));
520 struct thread_info *tp;
524 /* First see if we are dealing with a thread-group id. */
527 struct inferior *inf;
528 int id = strtoul (argv[0] + 1, &end, 0);
531 error (_("Invalid syntax of thread-group id '%s'"), argv[0]);
533 inf = find_inferior_id (id);
535 error (_("Non-existent thread-group id '%d'"), id);
541 /* We must be dealing with a pid. */
542 pid = strtol (argv[0], &end, 10);
545 error (_("Invalid identifier '%s'"), argv[0]);
548 /* Pick any thread in the desired process. Current
549 target_detach detaches from the parent of inferior_ptid. */
550 tp = iterate_over_threads (find_thread_of_process, &pid);
552 error (_("Thread group is empty"));
554 switch_to_thread (tp->ptid);
557 detach_command (NULL, 0);
561 mi_cmd_thread_select (char *command, char **argv, int argc)
564 char *mi_error_message;
567 error (_("-thread-select: USAGE: threadnum."));
569 rc = gdb_thread_select (current_uiout, argv[0], &mi_error_message);
571 if (rc == GDB_RC_FAIL)
573 make_cleanup (xfree, mi_error_message);
574 error ("%s", mi_error_message);
579 mi_cmd_thread_list_ids (char *command, char **argv, int argc)
582 char *mi_error_message;
585 error (_("-thread-list-ids: No arguments required."));
587 rc = gdb_list_thread_ids (current_uiout, &mi_error_message);
589 if (rc == GDB_RC_FAIL)
591 make_cleanup (xfree, mi_error_message);
592 error ("%s", mi_error_message);
597 mi_cmd_thread_info (char *command, char **argv, int argc)
599 if (argc != 0 && argc != 1)
600 error (_("Invalid MI command"));
602 print_thread_info (current_uiout, argv[0], -1);
605 struct collect_cores_data
613 collect_cores (struct thread_info *ti, void *xdata)
615 struct collect_cores_data *data = xdata;
617 if (ptid_get_pid (ti->ptid) == data->pid)
619 int core = target_core_of_thread (ti->ptid);
622 VEC_safe_push (int, data->cores, core);
629 unique (int *b, int *e)
639 struct print_one_inferior_data
642 VEC (int) *inferiors;
646 print_one_inferior (struct inferior *inferior, void *xdata)
648 struct print_one_inferior_data *top_data = xdata;
649 struct ui_out *uiout = current_uiout;
651 if (VEC_empty (int, top_data->inferiors)
652 || bsearch (&(inferior->pid), VEC_address (int, top_data->inferiors),
653 VEC_length (int, top_data->inferiors), sizeof (int),
654 compare_positive_ints))
656 struct collect_cores_data data;
657 struct cleanup *back_to
658 = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
660 ui_out_field_fmt (uiout, "id", "i%d", inferior->num);
661 ui_out_field_string (uiout, "type", "process");
662 if (inferior->pid != 0)
663 ui_out_field_int (uiout, "pid", inferior->pid);
665 if (inferior->pspace->pspace_exec_filename != NULL)
667 ui_out_field_string (uiout, "executable",
668 inferior->pspace->pspace_exec_filename);
672 if (inferior->pid != 0)
674 data.pid = inferior->pid;
675 iterate_over_threads (collect_cores, &data);
678 if (!VEC_empty (int, data.cores))
681 struct cleanup *back_to_2 =
682 make_cleanup_ui_out_list_begin_end (uiout, "cores");
684 qsort (VEC_address (int, data.cores),
685 VEC_length (int, data.cores), sizeof (int),
686 compare_positive_ints);
688 b = VEC_address (int, data.cores);
689 e = b + VEC_length (int, data.cores);
693 ui_out_field_int (uiout, NULL, *b);
695 do_cleanups (back_to_2);
698 if (top_data->recurse)
699 print_thread_info (uiout, NULL, inferior->pid);
701 do_cleanups (back_to);
707 /* Output a field named 'cores' with a list as the value. The
708 elements of the list are obtained by splitting 'cores' on
712 output_cores (struct ui_out *uiout, const char *field_name, const char *xcores)
714 struct cleanup *back_to = make_cleanup_ui_out_list_begin_end (uiout,
716 char *cores = xstrdup (xcores);
719 make_cleanup (xfree, cores);
721 for (p = strtok (p, ","); p; p = strtok (NULL, ","))
722 ui_out_field_string (uiout, NULL, p);
724 do_cleanups (back_to);
728 free_vector_of_ints (void *xvector)
730 VEC (int) **vector = xvector;
732 VEC_free (int, *vector);
736 do_nothing (splay_tree_key k)
741 free_vector_of_osdata_items (splay_tree_value xvalue)
743 VEC (osdata_item_s) *value = (VEC (osdata_item_s) *) xvalue;
745 /* We don't free the items itself, it will be done separately. */
746 VEC_free (osdata_item_s, value);
750 splay_tree_int_comparator (splay_tree_key xa, splay_tree_key xb)
759 free_splay_tree (void *xt)
762 splay_tree_delete (t);
766 list_available_thread_groups (VEC (int) *ids, int recurse)
769 struct osdata_item *item;
771 struct ui_out *uiout = current_uiout;
772 struct cleanup *cleanup;
774 /* This keeps a map from integer (pid) to VEC (struct osdata_item *)*
775 The vector contains information about all threads for the given pid.
776 This is assigned an initial value to avoid "may be used uninitialized"
778 splay_tree tree = NULL;
780 /* get_osdata will throw if it cannot return data. */
781 data = get_osdata ("processes");
782 cleanup = make_cleanup_osdata_free (data);
786 struct osdata *threads = get_osdata ("threads");
788 make_cleanup_osdata_free (threads);
789 tree = splay_tree_new (splay_tree_int_comparator,
791 free_vector_of_osdata_items);
792 make_cleanup (free_splay_tree, tree);
795 VEC_iterate (osdata_item_s, threads->items,
799 const char *pid = get_osdata_column (item, "pid");
800 int pid_i = strtoul (pid, NULL, 0);
801 VEC (osdata_item_s) *vec = 0;
803 splay_tree_node n = splay_tree_lookup (tree, pid_i);
806 VEC_safe_push (osdata_item_s, vec, item);
807 splay_tree_insert (tree, pid_i, (splay_tree_value)vec);
811 vec = (VEC (osdata_item_s) *) n->value;
812 VEC_safe_push (osdata_item_s, vec, item);
813 n->value = (splay_tree_value) vec;
818 make_cleanup_ui_out_list_begin_end (uiout, "groups");
821 VEC_iterate (osdata_item_s, data->items,
825 struct cleanup *back_to;
827 const char *pid = get_osdata_column (item, "pid");
828 const char *cmd = get_osdata_column (item, "command");
829 const char *user = get_osdata_column (item, "user");
830 const char *cores = get_osdata_column (item, "cores");
832 int pid_i = strtoul (pid, NULL, 0);
834 /* At present, the target will return all available processes
835 and if information about specific ones was required, we filter
836 undesired processes here. */
837 if (ids && bsearch (&pid_i, VEC_address (int, ids),
838 VEC_length (int, ids),
839 sizeof (int), compare_positive_ints) == NULL)
843 back_to = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
845 ui_out_field_fmt (uiout, "id", "%s", pid);
846 ui_out_field_string (uiout, "type", "process");
848 ui_out_field_string (uiout, "description", cmd);
850 ui_out_field_string (uiout, "user", user);
852 output_cores (uiout, "cores", cores);
856 splay_tree_node n = splay_tree_lookup (tree, pid_i);
859 VEC (osdata_item_s) *children = (VEC (osdata_item_s) *) n->value;
860 struct osdata_item *child;
863 make_cleanup_ui_out_list_begin_end (uiout, "threads");
866 VEC_iterate (osdata_item_s, children, ix_child, child);
869 struct cleanup *back_to_2 =
870 make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
871 const char *tid = get_osdata_column (child, "tid");
872 const char *tcore = get_osdata_column (child, "core");
874 ui_out_field_string (uiout, "id", tid);
876 ui_out_field_string (uiout, "core", tcore);
878 do_cleanups (back_to_2);
883 do_cleanups (back_to);
886 do_cleanups (cleanup);
890 mi_cmd_list_thread_groups (char *command, char **argv, int argc)
892 struct ui_out *uiout = current_uiout;
893 struct cleanup *back_to;
900 AVAILABLE_OPT, RECURSE_OPT
902 static const struct mi_opt opts[] =
904 {"-available", AVAILABLE_OPT, 0},
905 {"-recurse", RECURSE_OPT, 1},
914 int opt = mi_getopt ("-list-thread-groups", argc, argv, opts,
919 switch ((enum opt) opt)
925 if (strcmp (oarg, "0") == 0)
927 else if (strcmp (oarg, "1") == 0)
930 error (_("only '0' and '1' are valid values "
931 "for the '--recurse' option"));
936 for (; oind < argc; ++oind)
941 if (*(argv[oind]) != 'i')
942 error (_("invalid syntax of group id '%s'"), argv[oind]);
944 inf = strtoul (argv[oind] + 1, &end, 0);
947 error (_("invalid syntax of group id '%s'"), argv[oind]);
948 VEC_safe_push (int, ids, inf);
950 if (VEC_length (int, ids) > 1)
951 qsort (VEC_address (int, ids),
952 VEC_length (int, ids),
953 sizeof (int), compare_positive_ints);
955 back_to = make_cleanup (free_vector_of_ints, &ids);
959 list_available_thread_groups (ids, recurse);
961 else if (VEC_length (int, ids) == 1)
963 /* Local thread groups, single id. */
964 int id = *VEC_address (int, ids);
965 struct inferior *inf = find_inferior_id (id);
968 error (_("Non-existent thread group id '%d'"), id);
970 print_thread_info (uiout, NULL, inf->pid);
974 struct print_one_inferior_data data;
976 data.recurse = recurse;
977 data.inferiors = ids;
979 /* Local thread groups. Either no explicit ids -- and we
980 print everything, or several explicit ids. In both cases,
981 we print more than one group, and have to use 'groups'
982 as the top-level element. */
983 make_cleanup_ui_out_list_begin_end (uiout, "groups");
984 update_thread_list ();
985 iterate_over_inferiors (print_one_inferior, &data);
988 do_cleanups (back_to);
992 mi_cmd_data_list_register_names (char *command, char **argv, int argc)
994 struct gdbarch *gdbarch;
995 struct ui_out *uiout = current_uiout;
998 struct cleanup *cleanup;
1000 /* Note that the test for a valid register must include checking the
1001 gdbarch_register_name because gdbarch_num_regs may be allocated
1002 for the union of the register sets within a family of related
1003 processors. In this case, some entries of gdbarch_register_name
1004 will change depending upon the particular processor being
1007 gdbarch = get_current_arch ();
1008 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
1010 cleanup = make_cleanup_ui_out_list_begin_end (uiout, "register-names");
1012 if (argc == 0) /* No args, just do all the regs. */
1018 if (gdbarch_register_name (gdbarch, regnum) == NULL
1019 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
1020 ui_out_field_string (uiout, NULL, "");
1022 ui_out_field_string (uiout, NULL,
1023 gdbarch_register_name (gdbarch, regnum));
1027 /* Else, list of register #s, just do listed regs. */
1028 for (i = 0; i < argc; i++)
1030 regnum = atoi (argv[i]);
1031 if (regnum < 0 || regnum >= numregs)
1032 error (_("bad register number"));
1034 if (gdbarch_register_name (gdbarch, regnum) == NULL
1035 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
1036 ui_out_field_string (uiout, NULL, "");
1038 ui_out_field_string (uiout, NULL,
1039 gdbarch_register_name (gdbarch, regnum));
1041 do_cleanups (cleanup);
1045 mi_cmd_data_list_changed_registers (char *command, char **argv, int argc)
1047 static struct regcache *this_regs = NULL;
1048 struct ui_out *uiout = current_uiout;
1049 struct regcache *prev_regs;
1050 struct gdbarch *gdbarch;
1051 int regnum, numregs, changed;
1053 struct cleanup *cleanup;
1055 /* The last time we visited this function, the current frame's
1056 register contents were saved in THIS_REGS. Move THIS_REGS over
1057 to PREV_REGS, and refresh THIS_REGS with the now-current register
1060 prev_regs = this_regs;
1061 this_regs = frame_save_as_regcache (get_selected_frame (NULL));
1062 cleanup = make_cleanup_regcache_xfree (prev_regs);
1064 /* Note that the test for a valid register must include checking the
1065 gdbarch_register_name because gdbarch_num_regs may be allocated
1066 for the union of the register sets within a family of related
1067 processors. In this case, some entries of gdbarch_register_name
1068 will change depending upon the particular processor being
1071 gdbarch = get_regcache_arch (this_regs);
1072 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
1074 make_cleanup_ui_out_list_begin_end (uiout, "changed-registers");
1078 /* No args, just do all the regs. */
1083 if (gdbarch_register_name (gdbarch, regnum) == NULL
1084 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
1086 changed = register_changed_p (regnum, prev_regs, this_regs);
1088 error (_("-data-list-changed-registers: "
1089 "Unable to read register contents."));
1091 ui_out_field_int (uiout, NULL, regnum);
1095 /* Else, list of register #s, just do listed regs. */
1096 for (i = 0; i < argc; i++)
1098 regnum = atoi (argv[i]);
1102 && gdbarch_register_name (gdbarch, regnum) != NULL
1103 && *gdbarch_register_name (gdbarch, regnum) != '\000')
1105 changed = register_changed_p (regnum, prev_regs, this_regs);
1107 error (_("-data-list-changed-registers: "
1108 "Unable to read register contents."));
1110 ui_out_field_int (uiout, NULL, regnum);
1113 error (_("bad register number"));
1115 do_cleanups (cleanup);
1119 register_changed_p (int regnum, struct regcache *prev_regs,
1120 struct regcache *this_regs)
1122 struct gdbarch *gdbarch = get_regcache_arch (this_regs);
1123 gdb_byte prev_buffer[MAX_REGISTER_SIZE];
1124 gdb_byte this_buffer[MAX_REGISTER_SIZE];
1125 enum register_status prev_status;
1126 enum register_status this_status;
1128 /* First time through or after gdbarch change consider all registers
1130 if (!prev_regs || get_regcache_arch (prev_regs) != gdbarch)
1133 /* Get register contents and compare. */
1134 prev_status = regcache_cooked_read (prev_regs, regnum, prev_buffer);
1135 this_status = regcache_cooked_read (this_regs, regnum, this_buffer);
1137 if (this_status != prev_status)
1139 else if (this_status == REG_VALID)
1140 return memcmp (prev_buffer, this_buffer,
1141 register_size (gdbarch, regnum)) != 0;
1146 /* Return a list of register number and value pairs. The valid
1147 arguments expected are: a letter indicating the format in which to
1148 display the registers contents. This can be one of: x
1149 (hexadecimal), d (decimal), N (natural), t (binary), o (octal), r
1150 (raw). After the format argument there can be a sequence of
1151 numbers, indicating which registers to fetch the content of. If
1152 the format is the only argument, a list of all the registers with
1153 their values is returned. */
1156 mi_cmd_data_list_register_values (char *command, char **argv, int argc)
1158 struct ui_out *uiout = current_uiout;
1159 struct frame_info *frame;
1160 struct gdbarch *gdbarch;
1161 int regnum, numregs, format;
1163 struct cleanup *list_cleanup;
1164 int skip_unavailable = 0;
1170 static const struct mi_opt opts[] =
1172 {"-skip-unavailable", SKIP_UNAVAILABLE, 0},
1176 /* Note that the test for a valid register must include checking the
1177 gdbarch_register_name because gdbarch_num_regs may be allocated
1178 for the union of the register sets within a family of related
1179 processors. In this case, some entries of gdbarch_register_name
1180 will change depending upon the particular processor being
1186 int opt = mi_getopt ("-data-list-register-values", argc, argv,
1187 opts, &oind, &oarg);
1191 switch ((enum opt) opt)
1193 case SKIP_UNAVAILABLE:
1194 skip_unavailable = 1;
1199 if (argc - oind < 1)
1200 error (_("-data-list-register-values: Usage: "
1201 "-data-list-register-values [--skip-unavailable] <format>"
1202 " [<regnum1>...<regnumN>]"));
1204 format = (int) argv[oind][0];
1206 frame = get_selected_frame (NULL);
1207 gdbarch = get_frame_arch (frame);
1208 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
1210 list_cleanup = make_cleanup_ui_out_list_begin_end (uiout, "register-values");
1212 if (argc - oind == 1)
1214 /* No args, beside the format: do all the regs. */
1219 if (gdbarch_register_name (gdbarch, regnum) == NULL
1220 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
1223 output_register (frame, regnum, format, skip_unavailable);
1227 /* Else, list of register #s, just do listed regs. */
1228 for (i = 1 + oind; i < argc; i++)
1230 regnum = atoi (argv[i]);
1234 && gdbarch_register_name (gdbarch, regnum) != NULL
1235 && *gdbarch_register_name (gdbarch, regnum) != '\000')
1236 output_register (frame, regnum, format, skip_unavailable);
1238 error (_("bad register number"));
1240 do_cleanups (list_cleanup);
1243 /* Output one register REGNUM's contents in the desired FORMAT. If
1244 SKIP_UNAVAILABLE is true, skip the register if it is
1248 output_register (struct frame_info *frame, int regnum, int format,
1249 int skip_unavailable)
1251 struct gdbarch *gdbarch = get_frame_arch (frame);
1252 struct ui_out *uiout = current_uiout;
1253 struct value *val = value_of_register (regnum, frame);
1254 struct cleanup *tuple_cleanup;
1255 struct value_print_options opts;
1256 struct ui_file *stb;
1258 if (skip_unavailable && !value_entirely_available (val))
1261 tuple_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1262 ui_out_field_int (uiout, "number", regnum);
1270 stb = mem_fileopen ();
1271 make_cleanup_ui_file_delete (stb);
1273 get_formatted_print_options (&opts, format);
1275 val_print (value_type (val),
1276 value_contents_for_printing (val),
1277 value_embedded_offset (val), 0,
1278 stb, 0, val, &opts, current_language);
1279 ui_out_field_stream (uiout, "value", stb);
1281 do_cleanups (tuple_cleanup);
1284 /* Write given values into registers. The registers and values are
1285 given as pairs. The corresponding MI command is
1286 -data-write-register-values <format>
1287 [<regnum1> <value1>...<regnumN> <valueN>] */
1289 mi_cmd_data_write_register_values (char *command, char **argv, int argc)
1291 struct regcache *regcache;
1292 struct gdbarch *gdbarch;
1295 /* Note that the test for a valid register must include checking the
1296 gdbarch_register_name because gdbarch_num_regs may be allocated
1297 for the union of the register sets within a family of related
1298 processors. In this case, some entries of gdbarch_register_name
1299 will change depending upon the particular processor being
1302 regcache = get_current_regcache ();
1303 gdbarch = get_regcache_arch (regcache);
1304 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
1307 error (_("-data-write-register-values: Usage: -data-write-register-"
1308 "values <format> [<regnum1> <value1>...<regnumN> <valueN>]"));
1310 if (!target_has_registers)
1311 error (_("-data-write-register-values: No registers."));
1314 error (_("-data-write-register-values: No regs and values specified."));
1317 error (_("-data-write-register-values: "
1318 "Regs and vals are not in pairs."));
1320 for (i = 1; i < argc; i = i + 2)
1322 int regnum = atoi (argv[i]);
1324 if (regnum >= 0 && regnum < numregs
1325 && gdbarch_register_name (gdbarch, regnum)
1326 && *gdbarch_register_name (gdbarch, regnum))
1330 /* Get the value as a number. */
1331 value = parse_and_eval_address (argv[i + 1]);
1333 /* Write it down. */
1334 regcache_cooked_write_signed (regcache, regnum, value);
1337 error (_("bad register number"));
1341 /* Evaluate the value of the argument. The argument is an
1342 expression. If the expression contains spaces it needs to be
1343 included in double quotes. */
1346 mi_cmd_data_evaluate_expression (char *command, char **argv, int argc)
1348 struct expression *expr;
1349 struct cleanup *old_chain;
1351 struct ui_file *stb;
1352 struct value_print_options opts;
1353 struct ui_out *uiout = current_uiout;
1355 stb = mem_fileopen ();
1356 old_chain = make_cleanup_ui_file_delete (stb);
1359 error (_("-data-evaluate-expression: "
1360 "Usage: -data-evaluate-expression expression"));
1362 expr = parse_expression (argv[0]);
1364 make_cleanup (free_current_contents, &expr);
1366 val = evaluate_expression (expr);
1368 /* Print the result of the expression evaluation. */
1369 get_user_print_options (&opts);
1371 common_val_print (val, stb, 0, &opts, current_language);
1373 ui_out_field_stream (uiout, "value", stb);
1375 do_cleanups (old_chain);
1378 /* This is the -data-read-memory command.
1380 ADDR: start address of data to be dumped.
1381 WORD-FORMAT: a char indicating format for the ``word''. See
1383 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
1384 NR_ROW: Number of rows.
1385 NR_COL: The number of colums (words per row).
1386 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
1387 ASCHAR for unprintable characters.
1389 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
1390 displayes them. Returns:
1392 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
1395 The number of bytes read is SIZE*ROW*COL. */
1398 mi_cmd_data_read_memory (char *command, char **argv, int argc)
1400 struct gdbarch *gdbarch = get_current_arch ();
1401 struct ui_out *uiout = current_uiout;
1402 struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
1404 long total_bytes, nr_cols, nr_rows;
1406 struct type *word_type;
1419 static const struct mi_opt opts[] =
1421 {"o", OFFSET_OPT, 1},
1427 int opt = mi_getopt ("-data-read-memory", argc, argv, opts,
1432 switch ((enum opt) opt)
1435 offset = atol (oarg);
1442 if (argc < 5 || argc > 6)
1443 error (_("-data-read-memory: Usage: "
1444 "ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR]."));
1446 /* Extract all the arguments. */
1448 /* Start address of the memory dump. */
1449 addr = parse_and_eval_address (argv[0]) + offset;
1450 /* The format character to use when displaying a memory word. See
1451 the ``x'' command. */
1452 word_format = argv[1][0];
1453 /* The size of the memory word. */
1454 word_size = atol (argv[2]);
1458 word_type = builtin_type (gdbarch)->builtin_int8;
1462 word_type = builtin_type (gdbarch)->builtin_int16;
1466 word_type = builtin_type (gdbarch)->builtin_int32;
1470 word_type = builtin_type (gdbarch)->builtin_int64;
1474 word_type = builtin_type (gdbarch)->builtin_int8;
1477 /* The number of rows. */
1478 nr_rows = atol (argv[3]);
1480 error (_("-data-read-memory: invalid number of rows."));
1482 /* Number of bytes per row. */
1483 nr_cols = atol (argv[4]);
1485 error (_("-data-read-memory: invalid number of columns."));
1487 /* The un-printable character when printing ascii. */
1493 /* Create a buffer and read it in. */
1494 total_bytes = word_size * nr_rows * nr_cols;
1495 mbuf = xcalloc (total_bytes, 1);
1496 make_cleanup (xfree, mbuf);
1498 /* Dispatch memory reads to the topmost target, not the flattened
1500 nr_bytes = target_read (current_target.beneath,
1501 TARGET_OBJECT_MEMORY, NULL, mbuf,
1504 error (_("Unable to read memory."));
1506 /* Output the header information. */
1507 ui_out_field_core_addr (uiout, "addr", gdbarch, addr);
1508 ui_out_field_int (uiout, "nr-bytes", nr_bytes);
1509 ui_out_field_int (uiout, "total-bytes", total_bytes);
1510 ui_out_field_core_addr (uiout, "next-row",
1511 gdbarch, addr + word_size * nr_cols);
1512 ui_out_field_core_addr (uiout, "prev-row",
1513 gdbarch, addr - word_size * nr_cols);
1514 ui_out_field_core_addr (uiout, "next-page", gdbarch, addr + total_bytes);
1515 ui_out_field_core_addr (uiout, "prev-page", gdbarch, addr - total_bytes);
1517 /* Build the result as a two dimentional table. */
1519 struct ui_file *stream;
1520 struct cleanup *cleanup_stream;
1524 stream = mem_fileopen ();
1525 cleanup_stream = make_cleanup_ui_file_delete (stream);
1527 make_cleanup_ui_out_list_begin_end (uiout, "memory");
1528 for (row = 0, row_byte = 0;
1530 row++, row_byte += nr_cols * word_size)
1534 struct cleanup *cleanup_tuple;
1535 struct cleanup *cleanup_list_data;
1536 struct value_print_options opts;
1538 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1539 ui_out_field_core_addr (uiout, "addr", gdbarch, addr + row_byte);
1540 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr +
1542 cleanup_list_data = make_cleanup_ui_out_list_begin_end (uiout, "data");
1543 get_formatted_print_options (&opts, word_format);
1544 for (col = 0, col_byte = row_byte;
1546 col++, col_byte += word_size)
1548 if (col_byte + word_size > nr_bytes)
1550 ui_out_field_string (uiout, NULL, "N/A");
1554 ui_file_rewind (stream);
1555 print_scalar_formatted (mbuf + col_byte, word_type, &opts,
1556 word_asize, stream);
1557 ui_out_field_stream (uiout, NULL, stream);
1560 do_cleanups (cleanup_list_data);
1565 ui_file_rewind (stream);
1566 for (byte = row_byte;
1567 byte < row_byte + word_size * nr_cols; byte++)
1569 if (byte >= nr_bytes)
1570 fputc_unfiltered ('X', stream);
1571 else if (mbuf[byte] < 32 || mbuf[byte] > 126)
1572 fputc_unfiltered (aschar, stream);
1574 fputc_unfiltered (mbuf[byte], stream);
1576 ui_out_field_stream (uiout, "ascii", stream);
1578 do_cleanups (cleanup_tuple);
1580 do_cleanups (cleanup_stream);
1582 do_cleanups (cleanups);
1586 mi_cmd_data_read_memory_bytes (char *command, char **argv, int argc)
1588 struct gdbarch *gdbarch = get_current_arch ();
1589 struct ui_out *uiout = current_uiout;
1590 struct cleanup *cleanups;
1593 memory_read_result_s *read_result;
1595 VEC(memory_read_result_s) *result;
1603 static const struct mi_opt opts[] =
1605 {"o", OFFSET_OPT, 1},
1611 int opt = mi_getopt ("-data-read-memory-bytes", argc, argv, opts,
1615 switch ((enum opt) opt)
1618 offset = atol (oarg);
1626 error (_("Usage: [ -o OFFSET ] ADDR LENGTH."));
1628 addr = parse_and_eval_address (argv[0]) + offset;
1629 length = atol (argv[1]);
1631 result = read_memory_robust (current_target.beneath, addr, length);
1633 cleanups = make_cleanup (free_memory_read_result_vector, result);
1635 if (VEC_length (memory_read_result_s, result) == 0)
1636 error (_("Unable to read memory."));
1638 make_cleanup_ui_out_list_begin_end (uiout, "memory");
1640 VEC_iterate (memory_read_result_s, result, ix, read_result);
1643 struct cleanup *t = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1647 ui_out_field_core_addr (uiout, "begin", gdbarch, read_result->begin);
1648 ui_out_field_core_addr (uiout, "offset", gdbarch, read_result->begin
1650 ui_out_field_core_addr (uiout, "end", gdbarch, read_result->end);
1652 data = xmalloc ((read_result->end - read_result->begin) * 2 + 1);
1654 for (i = 0, p = data;
1655 i < (read_result->end - read_result->begin);
1658 sprintf (p, "%02x", read_result->data[i]);
1660 ui_out_field_string (uiout, "contents", data);
1664 do_cleanups (cleanups);
1667 /* Implementation of the -data-write_memory command.
1669 COLUMN_OFFSET: optional argument. Must be preceded by '-o'. The
1670 offset from the beginning of the memory grid row where the cell to
1672 ADDR: start address of the row in the memory grid where the memory
1673 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
1674 the location to write to.
1675 FORMAT: a char indicating format for the ``word''. See
1677 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
1678 VALUE: value to be written into the memory address.
1680 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1685 mi_cmd_data_write_memory (char *command, char **argv, int argc)
1687 struct gdbarch *gdbarch = get_current_arch ();
1688 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1691 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1692 enough when using a compiler other than GCC. */
1695 struct cleanup *old_chain;
1703 static const struct mi_opt opts[] =
1705 {"o", OFFSET_OPT, 1},
1711 int opt = mi_getopt ("-data-write-memory", argc, argv, opts,
1716 switch ((enum opt) opt)
1719 offset = atol (oarg);
1727 error (_("-data-write-memory: Usage: "
1728 "[-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE."));
1730 /* Extract all the arguments. */
1731 /* Start address of the memory dump. */
1732 addr = parse_and_eval_address (argv[0]);
1733 /* The size of the memory word. */
1734 word_size = atol (argv[2]);
1736 /* Calculate the real address of the write destination. */
1737 addr += (offset * word_size);
1739 /* Get the value as a number. */
1740 value = parse_and_eval_address (argv[3]);
1741 /* Get the value into an array. */
1742 buffer = xmalloc (word_size);
1743 old_chain = make_cleanup (xfree, buffer);
1744 store_signed_integer (buffer, word_size, byte_order, value);
1745 /* Write it down to memory. */
1746 write_memory_with_notification (addr, buffer, word_size);
1747 /* Free the buffer. */
1748 do_cleanups (old_chain);
1751 /* Implementation of the -data-write-memory-bytes command.
1754 DATA: string of bytes to write at that address
1755 COUNT: number of bytes to be filled (decimal integer). */
1758 mi_cmd_data_write_memory_bytes (char *command, char **argv, int argc)
1764 size_t len, i, steps, remainder;
1766 struct cleanup *back_to;
1768 if (argc != 2 && argc != 3)
1769 error (_("Usage: ADDR DATA [COUNT]."));
1771 addr = parse_and_eval_address (argv[0]);
1773 if (strlen (cdata) % 2)
1774 error (_("Hex-encoded '%s' must have an even number of characters."),
1777 len = strlen (cdata)/2;
1779 count = strtoul (argv[2], NULL, 10);
1783 databuf = xmalloc (len * sizeof (gdb_byte));
1784 back_to = make_cleanup (xfree, databuf);
1786 for (i = 0; i < len; ++i)
1789 if (sscanf (cdata + i * 2, "%02x", &x) != 1)
1790 error (_("Invalid argument"));
1791 databuf[i] = (gdb_byte) x;
1796 /* Pattern is made of less bytes than count:
1797 repeat pattern to fill memory. */
1798 data = xmalloc (count);
1799 make_cleanup (xfree, data);
1801 steps = count / len;
1802 remainder = count % len;
1803 for (j = 0; j < steps; j++)
1804 memcpy (data + j * len, databuf, len);
1807 memcpy (data + steps * len, databuf, remainder);
1811 /* Pattern is longer than or equal to count:
1812 just copy count bytes. */
1816 write_memory_with_notification (addr, data, count);
1818 do_cleanups (back_to);
1822 mi_cmd_enable_timings (char *command, char **argv, int argc)
1828 if (strcmp (argv[0], "yes") == 0)
1830 else if (strcmp (argv[0], "no") == 0)
1841 error (_("-enable-timings: Usage: %s {yes|no}"), command);
1845 mi_cmd_list_features (char *command, char **argv, int argc)
1849 struct cleanup *cleanup = NULL;
1850 struct ui_out *uiout = current_uiout;
1852 cleanup = make_cleanup_ui_out_list_begin_end (uiout, "features");
1853 ui_out_field_string (uiout, NULL, "frozen-varobjs");
1854 ui_out_field_string (uiout, NULL, "pending-breakpoints");
1855 ui_out_field_string (uiout, NULL, "thread-info");
1856 ui_out_field_string (uiout, NULL, "data-read-memory-bytes");
1857 ui_out_field_string (uiout, NULL, "breakpoint-notifications");
1858 ui_out_field_string (uiout, NULL, "ada-task-info");
1859 ui_out_field_string (uiout, NULL, "language-option");
1860 ui_out_field_string (uiout, NULL, "info-gdb-mi-command");
1861 ui_out_field_string (uiout, NULL, "undefined-command-error-code");
1862 ui_out_field_string (uiout, NULL, "exec-run-start-option");
1864 if (ext_lang_initialized_p (get_ext_lang_defn (EXT_LANG_PYTHON)))
1865 ui_out_field_string (uiout, NULL, "python");
1867 do_cleanups (cleanup);
1871 error (_("-list-features should be passed no arguments"));
1875 mi_cmd_list_target_features (char *command, char **argv, int argc)
1879 struct cleanup *cleanup = NULL;
1880 struct ui_out *uiout = current_uiout;
1882 cleanup = make_cleanup_ui_out_list_begin_end (uiout, "features");
1884 ui_out_field_string (uiout, NULL, "async");
1885 if (target_can_execute_reverse)
1886 ui_out_field_string (uiout, NULL, "reverse");
1887 do_cleanups (cleanup);
1891 error (_("-list-target-features should be passed no arguments"));
1895 mi_cmd_add_inferior (char *command, char **argv, int argc)
1897 struct inferior *inf;
1900 error (_("-add-inferior should be passed no arguments"));
1902 inf = add_inferior_with_spaces ();
1904 ui_out_field_fmt (current_uiout, "inferior", "i%d", inf->num);
1907 /* Callback used to find the first inferior other than the current
1911 get_other_inferior (struct inferior *inf, void *arg)
1913 if (inf == current_inferior ())
1920 mi_cmd_remove_inferior (char *command, char **argv, int argc)
1923 struct inferior *inf;
1926 error (_("-remove-inferior should be passed a single argument"));
1928 if (sscanf (argv[0], "i%d", &id) != 1)
1929 error (_("the thread group id is syntactically invalid"));
1931 inf = find_inferior_id (id);
1933 error (_("the specified thread group does not exist"));
1936 error (_("cannot remove an active inferior"));
1938 if (inf == current_inferior ())
1940 struct thread_info *tp = 0;
1941 struct inferior *new_inferior
1942 = iterate_over_inferiors (get_other_inferior, NULL);
1944 if (new_inferior == NULL)
1945 error (_("Cannot remove last inferior"));
1947 set_current_inferior (new_inferior);
1948 if (new_inferior->pid != 0)
1949 tp = any_thread_of_process (new_inferior->pid);
1950 switch_to_thread (tp ? tp->ptid : null_ptid);
1951 set_current_program_space (new_inferior->pspace);
1954 delete_inferior_1 (inf, 1 /* silent */);
1959 /* Execute a command within a safe environment.
1960 Return <0 for error; >=0 for ok.
1962 args->action will tell mi_execute_command what action
1963 to perfrom after the given command has executed (display/suppress
1964 prompt, display error). */
1967 captured_mi_execute_command (struct ui_out *uiout, struct mi_parse *context)
1969 struct cleanup *cleanup;
1972 current_command_ts = context->cmd_start;
1974 current_token = xstrdup (context->token);
1975 cleanup = make_cleanup (free_current_contents, ¤t_token);
1977 running_result_record_printed = 0;
1979 switch (context->op)
1982 /* A MI command was read from the input stream. */
1984 /* FIXME: gdb_???? */
1985 fprintf_unfiltered (raw_stdout, " token=`%s' command=`%s' args=`%s'\n",
1986 context->token, context->command, context->args);
1988 mi_cmd_execute (context);
1990 /* Print the result if there were no errors.
1992 Remember that on the way out of executing a command, you have
1993 to directly use the mi_interp's uiout, since the command
1994 could have reset the interpreter, in which case the current
1995 uiout will most likely crash in the mi_out_* routines. */
1996 if (!running_result_record_printed)
1998 fputs_unfiltered (context->token, raw_stdout);
1999 /* There's no particularly good reason why target-connect results
2000 in not ^done. Should kill ^connected for MI3. */
2001 fputs_unfiltered (strcmp (context->command, "target-select") == 0
2002 ? "^connected" : "^done", raw_stdout);
2003 mi_out_put (uiout, raw_stdout);
2004 mi_out_rewind (uiout);
2005 mi_print_timing_maybe ();
2006 fputs_unfiltered ("\n", raw_stdout);
2009 /* The command does not want anything to be printed. In that
2010 case, the command probably should not have written anything
2011 to uiout, but in case it has written something, discard it. */
2012 mi_out_rewind (uiout);
2019 /* A CLI command was read from the input stream. */
2020 /* This "feature" will be removed as soon as we have a
2021 complete set of mi commands. */
2022 /* Echo the command on the console. */
2023 fprintf_unfiltered (gdb_stdlog, "%s\n", context->command);
2024 /* Call the "console" interpreter. */
2025 argv[0] = "console";
2026 argv[1] = context->command;
2027 mi_cmd_interpreter_exec ("-interpreter-exec", argv, 2);
2029 /* If we changed interpreters, DON'T print out anything. */
2030 if (current_interp_named_p (INTERP_MI)
2031 || current_interp_named_p (INTERP_MI1)
2032 || current_interp_named_p (INTERP_MI2)
2033 || current_interp_named_p (INTERP_MI3))
2035 if (!running_result_record_printed)
2037 fputs_unfiltered (context->token, raw_stdout);
2038 fputs_unfiltered ("^done", raw_stdout);
2039 mi_out_put (uiout, raw_stdout);
2040 mi_out_rewind (uiout);
2041 mi_print_timing_maybe ();
2042 fputs_unfiltered ("\n", raw_stdout);
2045 mi_out_rewind (uiout);
2051 do_cleanups (cleanup);
2054 /* Print a gdb exception to the MI output stream. */
2057 mi_print_exception (const char *token, struct gdb_exception exception)
2059 fputs_unfiltered (token, raw_stdout);
2060 fputs_unfiltered ("^error,msg=\"", raw_stdout);
2061 if (exception.message == NULL)
2062 fputs_unfiltered ("unknown error", raw_stdout);
2064 fputstr_unfiltered (exception.message, '"', raw_stdout);
2065 fputs_unfiltered ("\"", raw_stdout);
2067 switch (exception.error)
2069 case UNDEFINED_COMMAND_ERROR:
2070 fputs_unfiltered (",code=\"undefined-command\"", raw_stdout);
2074 fputs_unfiltered ("\n", raw_stdout);
2078 mi_execute_command (const char *cmd, int from_tty)
2081 struct mi_parse *command = NULL;
2082 volatile struct gdb_exception exception;
2084 /* This is to handle EOF (^D). We just quit gdb. */
2085 /* FIXME: we should call some API function here. */
2087 quit_force (NULL, from_tty);
2089 target_log_command (cmd);
2091 TRY_CATCH (exception, RETURN_MASK_ALL)
2093 command = mi_parse (cmd, &token);
2095 if (exception.reason < 0)
2097 mi_print_exception (token, exception);
2102 volatile struct gdb_exception result;
2103 ptid_t previous_ptid = inferior_ptid;
2105 command->token = token;
2109 command->cmd_start = (struct mi_timestamp *)
2110 xmalloc (sizeof (struct mi_timestamp));
2111 timestamp (command->cmd_start);
2114 TRY_CATCH (result, RETURN_MASK_ALL)
2116 captured_mi_execute_command (current_uiout, command);
2118 if (result.reason < 0)
2120 /* The command execution failed and error() was called
2122 mi_print_exception (command->token, result);
2123 mi_out_rewind (current_uiout);
2126 bpstat_do_actions ();
2128 if (/* The notifications are only output when the top-level
2129 interpreter (specified on the command line) is MI. */
2130 ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ()))
2131 /* Don't try report anything if there are no threads --
2132 the program is dead. */
2133 && thread_count () != 0
2134 /* -thread-select explicitly changes thread. If frontend uses that
2135 internally, we don't want to emit =thread-selected, since
2136 =thread-selected is supposed to indicate user's intentions. */
2137 && strcmp (command->command, "thread-select") != 0)
2139 struct mi_interp *mi = top_level_interpreter_data ();
2140 int report_change = 0;
2142 if (command->thread == -1)
2144 report_change = (!ptid_equal (previous_ptid, null_ptid)
2145 && !ptid_equal (inferior_ptid, previous_ptid)
2146 && !ptid_equal (inferior_ptid, null_ptid));
2148 else if (!ptid_equal (inferior_ptid, null_ptid))
2150 struct thread_info *ti = inferior_thread ();
2152 report_change = (ti->num != command->thread);
2157 struct thread_info *ti = inferior_thread ();
2159 target_terminal_ours ();
2160 fprintf_unfiltered (mi->event_channel,
2161 "thread-selected,id=\"%d\"",
2163 gdb_flush (mi->event_channel);
2167 mi_parse_free (command);
2172 mi_cmd_execute (struct mi_parse *parse)
2174 struct cleanup *cleanup;
2175 enum language saved_language;
2177 cleanup = prepare_execute_command ();
2179 if (parse->all && parse->thread_group != -1)
2180 error (_("Cannot specify --thread-group together with --all"));
2182 if (parse->all && parse->thread != -1)
2183 error (_("Cannot specify --thread together with --all"));
2185 if (parse->thread_group != -1 && parse->thread != -1)
2186 error (_("Cannot specify --thread together with --thread-group"));
2188 if (parse->frame != -1 && parse->thread == -1)
2189 error (_("Cannot specify --frame without --thread"));
2191 if (parse->thread_group != -1)
2193 struct inferior *inf = find_inferior_id (parse->thread_group);
2194 struct thread_info *tp = 0;
2197 error (_("Invalid thread group for the --thread-group option"));
2199 set_current_inferior (inf);
2200 /* This behaviour means that if --thread-group option identifies
2201 an inferior with multiple threads, then a random one will be
2202 picked. This is not a problem -- frontend should always
2203 provide --thread if it wishes to operate on a specific
2206 tp = any_live_thread_of_process (inf->pid);
2207 switch_to_thread (tp ? tp->ptid : null_ptid);
2208 set_current_program_space (inf->pspace);
2211 if (parse->thread != -1)
2213 struct thread_info *tp = find_thread_id (parse->thread);
2216 error (_("Invalid thread id: %d"), parse->thread);
2218 if (is_exited (tp->ptid))
2219 error (_("Thread id: %d has terminated"), parse->thread);
2221 switch_to_thread (tp->ptid);
2224 if (parse->frame != -1)
2226 struct frame_info *fid;
2227 int frame = parse->frame;
2229 fid = find_relative_frame (get_current_frame (), &frame);
2231 /* find_relative_frame was successful */
2234 error (_("Invalid frame id: %d"), frame);
2237 if (parse->language != language_unknown)
2239 make_cleanup_restore_current_language ();
2240 set_language (parse->language);
2243 current_context = parse;
2245 if (parse->cmd->suppress_notification != NULL)
2247 make_cleanup_restore_integer (parse->cmd->suppress_notification);
2248 *parse->cmd->suppress_notification = 1;
2251 if (parse->cmd->argv_func != NULL)
2253 parse->cmd->argv_func (parse->command, parse->argv, parse->argc);
2255 else if (parse->cmd->cli.cmd != 0)
2257 /* FIXME: DELETE THIS. */
2258 /* The operation is still implemented by a cli command. */
2259 /* Must be a synchronous one. */
2260 mi_execute_cli_command (parse->cmd->cli.cmd, parse->cmd->cli.args_p,
2265 /* FIXME: DELETE THIS. */
2266 struct ui_file *stb;
2268 stb = mem_fileopen ();
2270 fputs_unfiltered ("Undefined mi command: ", stb);
2271 fputstr_unfiltered (parse->command, '"', stb);
2272 fputs_unfiltered (" (missing implementation)", stb);
2274 make_cleanup_ui_file_delete (stb);
2277 do_cleanups (cleanup);
2280 /* FIXME: This is just a hack so we can get some extra commands going.
2281 We don't want to channel things through the CLI, but call libgdb directly.
2282 Use only for synchronous commands. */
2285 mi_execute_cli_command (const char *cmd, int args_p, const char *args)
2289 struct cleanup *old_cleanups;
2293 run = xstrprintf ("%s %s", cmd, args);
2295 run = xstrdup (cmd);
2297 /* FIXME: gdb_???? */
2298 fprintf_unfiltered (gdb_stdout, "cli=%s run=%s\n",
2300 old_cleanups = make_cleanup (xfree, run);
2301 execute_command (run, 0 /* from_tty */ );
2302 do_cleanups (old_cleanups);
2308 mi_execute_async_cli_command (char *cli_command, char **argv, int argc)
2310 struct cleanup *old_cleanups;
2314 run = xstrprintf ("%s %s&", cli_command, argc ? *argv : "");
2316 run = xstrprintf ("%s %s", cli_command, argc ? *argv : "");
2317 old_cleanups = make_cleanup (xfree, run);
2319 execute_command (run, 0 /* from_tty */ );
2321 /* Do this before doing any printing. It would appear that some
2322 print code leaves garbage around in the buffer. */
2323 do_cleanups (old_cleanups);
2327 mi_load_progress (const char *section_name,
2328 unsigned long sent_so_far,
2329 unsigned long total_section,
2330 unsigned long total_sent,
2331 unsigned long grand_total)
2333 struct timeval time_now, delta, update_threshold;
2334 static struct timeval last_update;
2335 static char *previous_sect_name = NULL;
2337 struct ui_out *saved_uiout;
2338 struct ui_out *uiout;
2340 /* This function is called through deprecated_show_load_progress
2341 which means uiout may not be correct. Fix it for the duration
2342 of this function. */
2343 saved_uiout = current_uiout;
2345 if (current_interp_named_p (INTERP_MI)
2346 || current_interp_named_p (INTERP_MI2))
2347 current_uiout = mi_out_new (2);
2348 else if (current_interp_named_p (INTERP_MI1))
2349 current_uiout = mi_out_new (1);
2350 else if (current_interp_named_p (INTERP_MI3))
2351 current_uiout = mi_out_new (3);
2355 uiout = current_uiout;
2357 update_threshold.tv_sec = 0;
2358 update_threshold.tv_usec = 500000;
2359 gettimeofday (&time_now, NULL);
2361 delta.tv_usec = time_now.tv_usec - last_update.tv_usec;
2362 delta.tv_sec = time_now.tv_sec - last_update.tv_sec;
2364 if (delta.tv_usec < 0)
2367 delta.tv_usec += 1000000L;
2370 new_section = (previous_sect_name ?
2371 strcmp (previous_sect_name, section_name) : 1);
2374 struct cleanup *cleanup_tuple;
2376 xfree (previous_sect_name);
2377 previous_sect_name = xstrdup (section_name);
2380 fputs_unfiltered (current_token, raw_stdout);
2381 fputs_unfiltered ("+download", raw_stdout);
2382 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
2383 ui_out_field_string (uiout, "section", section_name);
2384 ui_out_field_int (uiout, "section-size", total_section);
2385 ui_out_field_int (uiout, "total-size", grand_total);
2386 do_cleanups (cleanup_tuple);
2387 mi_out_put (uiout, raw_stdout);
2388 fputs_unfiltered ("\n", raw_stdout);
2389 gdb_flush (raw_stdout);
2392 if (delta.tv_sec >= update_threshold.tv_sec &&
2393 delta.tv_usec >= update_threshold.tv_usec)
2395 struct cleanup *cleanup_tuple;
2397 last_update.tv_sec = time_now.tv_sec;
2398 last_update.tv_usec = time_now.tv_usec;
2400 fputs_unfiltered (current_token, raw_stdout);
2401 fputs_unfiltered ("+download", raw_stdout);
2402 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
2403 ui_out_field_string (uiout, "section", section_name);
2404 ui_out_field_int (uiout, "section-sent", sent_so_far);
2405 ui_out_field_int (uiout, "section-size", total_section);
2406 ui_out_field_int (uiout, "total-sent", total_sent);
2407 ui_out_field_int (uiout, "total-size", grand_total);
2408 do_cleanups (cleanup_tuple);
2409 mi_out_put (uiout, raw_stdout);
2410 fputs_unfiltered ("\n", raw_stdout);
2411 gdb_flush (raw_stdout);
2415 current_uiout = saved_uiout;
2419 timestamp (struct mi_timestamp *tv)
2421 gettimeofday (&tv->wallclock, NULL);
2422 #ifdef HAVE_GETRUSAGE
2423 getrusage (RUSAGE_SELF, &rusage);
2424 tv->utime.tv_sec = rusage.ru_utime.tv_sec;
2425 tv->utime.tv_usec = rusage.ru_utime.tv_usec;
2426 tv->stime.tv_sec = rusage.ru_stime.tv_sec;
2427 tv->stime.tv_usec = rusage.ru_stime.tv_usec;
2430 long usec = get_run_time ();
2432 tv->utime.tv_sec = usec/1000000L;
2433 tv->utime.tv_usec = usec - 1000000L*tv->utime.tv_sec;
2434 tv->stime.tv_sec = 0;
2435 tv->stime.tv_usec = 0;
2441 print_diff_now (struct mi_timestamp *start)
2443 struct mi_timestamp now;
2446 print_diff (start, &now);
2450 mi_print_timing_maybe (void)
2452 /* If the command is -enable-timing then do_timings may be true
2453 whilst current_command_ts is not initialized. */
2454 if (do_timings && current_command_ts)
2455 print_diff_now (current_command_ts);
2459 timeval_diff (struct timeval start, struct timeval end)
2461 return ((end.tv_sec - start.tv_sec) * 1000000L)
2462 + (end.tv_usec - start.tv_usec);
2466 print_diff (struct mi_timestamp *start, struct mi_timestamp *end)
2470 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
2471 timeval_diff (start->wallclock, end->wallclock) / 1000000.0,
2472 timeval_diff (start->utime, end->utime) / 1000000.0,
2473 timeval_diff (start->stime, end->stime) / 1000000.0);
2477 mi_cmd_trace_define_variable (char *command, char **argv, int argc)
2479 struct expression *expr;
2480 LONGEST initval = 0;
2481 struct trace_state_variable *tsv;
2484 if (argc != 1 && argc != 2)
2485 error (_("Usage: -trace-define-variable VARIABLE [VALUE]"));
2489 error (_("Name of trace variable should start with '$'"));
2491 validate_trace_state_variable_name (name);
2493 tsv = find_trace_state_variable (name);
2495 tsv = create_trace_state_variable (name);
2498 initval = value_as_long (parse_and_eval (argv[1]));
2500 tsv->initial_value = initval;
2504 mi_cmd_trace_list_variables (char *command, char **argv, int argc)
2507 error (_("-trace-list-variables: no arguments allowed"));
2509 tvariables_info_1 ();
2513 mi_cmd_trace_find (char *command, char **argv, int argc)
2518 error (_("trace selection mode is required"));
2522 if (strcmp (mode, "none") == 0)
2524 tfind_1 (tfind_number, -1, 0, 0, 0);
2528 check_trace_running (current_trace_status ());
2530 if (strcmp (mode, "frame-number") == 0)
2533 error (_("frame number is required"));
2534 tfind_1 (tfind_number, atoi (argv[1]), 0, 0, 0);
2536 else if (strcmp (mode, "tracepoint-number") == 0)
2539 error (_("tracepoint number is required"));
2540 tfind_1 (tfind_tp, atoi (argv[1]), 0, 0, 0);
2542 else if (strcmp (mode, "pc") == 0)
2545 error (_("PC is required"));
2546 tfind_1 (tfind_pc, 0, parse_and_eval_address (argv[1]), 0, 0);
2548 else if (strcmp (mode, "pc-inside-range") == 0)
2551 error (_("Start and end PC are required"));
2552 tfind_1 (tfind_range, 0, parse_and_eval_address (argv[1]),
2553 parse_and_eval_address (argv[2]), 0);
2555 else if (strcmp (mode, "pc-outside-range") == 0)
2558 error (_("Start and end PC are required"));
2559 tfind_1 (tfind_outside, 0, parse_and_eval_address (argv[1]),
2560 parse_and_eval_address (argv[2]), 0);
2562 else if (strcmp (mode, "line") == 0)
2564 struct symtabs_and_lines sals;
2565 struct symtab_and_line sal;
2566 static CORE_ADDR start_pc, end_pc;
2567 struct cleanup *back_to;
2570 error (_("Line is required"));
2572 sals = decode_line_with_current_source (argv[1],
2573 DECODE_LINE_FUNFIRSTLINE);
2574 back_to = make_cleanup (xfree, sals.sals);
2578 if (sal.symtab == 0)
2579 error (_("Could not find the specified line"));
2581 if (sal.line > 0 && find_line_pc_range (sal, &start_pc, &end_pc))
2582 tfind_1 (tfind_range, 0, start_pc, end_pc - 1, 0);
2584 error (_("Could not find the specified line"));
2586 do_cleanups (back_to);
2589 error (_("Invalid mode '%s'"), mode);
2591 if (has_stack_frames () || get_traceframe_number () >= 0)
2592 print_stack_frame (get_selected_frame (NULL), 1, LOC_AND_ADDRESS, 1);
2596 mi_cmd_trace_save (char *command, char **argv, int argc)
2598 int target_saves = 0;
2599 int generate_ctf = 0;
2606 TARGET_SAVE_OPT, CTF_OPT
2608 static const struct mi_opt opts[] =
2610 {"r", TARGET_SAVE_OPT, 0},
2611 {"ctf", CTF_OPT, 0},
2617 int opt = mi_getopt ("-trace-save", argc, argv, opts,
2622 switch ((enum opt) opt)
2624 case TARGET_SAVE_OPT:
2632 filename = argv[oind];
2635 trace_save_ctf (filename, target_saves);
2637 trace_save_tfile (filename, target_saves);
2641 mi_cmd_trace_start (char *command, char **argv, int argc)
2643 start_tracing (NULL);
2647 mi_cmd_trace_status (char *command, char **argv, int argc)
2649 trace_status_mi (0);
2653 mi_cmd_trace_stop (char *command, char **argv, int argc)
2655 stop_tracing (NULL);
2656 trace_status_mi (1);
2659 /* Implement the "-ada-task-info" command. */
2662 mi_cmd_ada_task_info (char *command, char **argv, int argc)
2664 if (argc != 0 && argc != 1)
2665 error (_("Invalid MI command"));
2667 print_ada_task_info (current_uiout, argv[0], current_inferior ());
2670 /* Print EXPRESSION according to VALUES. */
2673 print_variable_or_computed (char *expression, enum print_values values)
2675 struct expression *expr;
2676 struct cleanup *old_chain;
2678 struct ui_file *stb;
2679 struct value_print_options opts;
2681 struct ui_out *uiout = current_uiout;
2683 stb = mem_fileopen ();
2684 old_chain = make_cleanup_ui_file_delete (stb);
2686 expr = parse_expression (expression);
2688 make_cleanup (free_current_contents, &expr);
2690 if (values == PRINT_SIMPLE_VALUES)
2691 val = evaluate_type (expr);
2693 val = evaluate_expression (expr);
2695 if (values != PRINT_NO_VALUES)
2696 make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
2697 ui_out_field_string (uiout, "name", expression);
2701 case PRINT_SIMPLE_VALUES:
2702 type = check_typedef (value_type (val));
2703 type_print (value_type (val), "", stb, -1);
2704 ui_out_field_stream (uiout, "type", stb);
2705 if (TYPE_CODE (type) != TYPE_CODE_ARRAY
2706 && TYPE_CODE (type) != TYPE_CODE_STRUCT
2707 && TYPE_CODE (type) != TYPE_CODE_UNION)
2709 struct value_print_options opts;
2711 get_no_prettyformat_print_options (&opts);
2713 common_val_print (val, stb, 0, &opts, current_language);
2714 ui_out_field_stream (uiout, "value", stb);
2717 case PRINT_ALL_VALUES:
2719 struct value_print_options opts;
2721 get_no_prettyformat_print_options (&opts);
2723 common_val_print (val, stb, 0, &opts, current_language);
2724 ui_out_field_stream (uiout, "value", stb);
2729 do_cleanups (old_chain);
2732 /* Implement the "-trace-frame-collected" command. */
2735 mi_cmd_trace_frame_collected (char *command, char **argv, int argc)
2737 struct cleanup *old_chain;
2738 struct bp_location *tloc;
2740 struct collection_list *clist;
2741 struct collection_list tracepoint_list, stepping_list;
2742 struct traceframe_info *tinfo;
2744 int var_print_values = PRINT_ALL_VALUES;
2745 int comp_print_values = PRINT_ALL_VALUES;
2746 int registers_format = 'x';
2747 int memory_contents = 0;
2748 struct ui_out *uiout = current_uiout;
2756 static const struct mi_opt opts[] =
2758 {"-var-print-values", VAR_PRINT_VALUES, 1},
2759 {"-comp-print-values", COMP_PRINT_VALUES, 1},
2760 {"-registers-format", REGISTERS_FORMAT, 1},
2761 {"-memory-contents", MEMORY_CONTENTS, 0},
2768 int opt = mi_getopt ("-trace-frame-collected", argc, argv, opts,
2772 switch ((enum opt) opt)
2774 case VAR_PRINT_VALUES:
2775 var_print_values = mi_parse_print_values (oarg);
2777 case COMP_PRINT_VALUES:
2778 comp_print_values = mi_parse_print_values (oarg);
2780 case REGISTERS_FORMAT:
2781 registers_format = oarg[0];
2782 case MEMORY_CONTENTS:
2783 memory_contents = 1;
2789 error (_("Usage: -trace-frame-collected "
2790 "[--var-print-values PRINT_VALUES] "
2791 "[--comp-print-values PRINT_VALUES] "
2792 "[--registers-format FORMAT]"
2793 "[--memory-contents]"));
2795 /* This throws an error is not inspecting a trace frame. */
2796 tloc = get_traceframe_location (&stepping_frame);
2798 /* This command only makes sense for the current frame, not the
2800 old_chain = make_cleanup_restore_current_thread ();
2801 select_frame (get_current_frame ());
2803 encode_actions_and_make_cleanup (tloc, &tracepoint_list,
2807 clist = &stepping_list;
2809 clist = &tracepoint_list;
2811 tinfo = get_traceframe_info ();
2813 /* Explicitly wholly collected variables. */
2815 struct cleanup *list_cleanup;
2819 list_cleanup = make_cleanup_ui_out_list_begin_end (uiout,
2820 "explicit-variables");
2821 for (i = 0; VEC_iterate (char_ptr, clist->wholly_collected, i, p); i++)
2822 print_variable_or_computed (p, var_print_values);
2823 do_cleanups (list_cleanup);
2826 /* Computed expressions. */
2828 struct cleanup *list_cleanup;
2833 = make_cleanup_ui_out_list_begin_end (uiout,
2834 "computed-expressions");
2835 for (i = 0; VEC_iterate (char_ptr, clist->computed, i, p); i++)
2836 print_variable_or_computed (p, comp_print_values);
2837 do_cleanups (list_cleanup);
2840 /* Registers. Given pseudo-registers, and that some architectures
2841 (like MIPS) actually hide the raw registers, we don't go through
2842 the trace frame info, but instead consult the register cache for
2843 register availability. */
2845 struct cleanup *list_cleanup;
2846 struct frame_info *frame;
2847 struct gdbarch *gdbarch;
2851 list_cleanup = make_cleanup_ui_out_list_begin_end (uiout, "registers");
2853 frame = get_selected_frame (NULL);
2854 gdbarch = get_frame_arch (frame);
2855 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
2857 for (regnum = 0; regnum < numregs; regnum++)
2859 if (gdbarch_register_name (gdbarch, regnum) == NULL
2860 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
2863 output_register (frame, regnum, registers_format, 1);
2866 do_cleanups (list_cleanup);
2869 /* Trace state variables. */
2871 struct cleanup *list_cleanup;
2876 list_cleanup = make_cleanup_ui_out_list_begin_end (uiout, "tvars");
2879 make_cleanup (free_current_contents, &tsvname);
2881 for (i = 0; VEC_iterate (int, tinfo->tvars, i, tvar); i++)
2883 struct cleanup *cleanup_child;
2884 struct trace_state_variable *tsv;
2886 tsv = find_trace_state_variable_by_number (tvar);
2888 cleanup_child = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
2892 tsvname = xrealloc (tsvname, strlen (tsv->name) + 2);
2894 strcpy (tsvname + 1, tsv->name);
2895 ui_out_field_string (uiout, "name", tsvname);
2897 tsv->value_known = target_get_trace_state_variable_value (tsv->number,
2899 ui_out_field_int (uiout, "current", tsv->value);
2903 ui_out_field_skip (uiout, "name");
2904 ui_out_field_skip (uiout, "current");
2907 do_cleanups (cleanup_child);
2910 do_cleanups (list_cleanup);
2915 struct cleanup *list_cleanup;
2916 VEC(mem_range_s) *available_memory = NULL;
2917 struct mem_range *r;
2920 traceframe_available_memory (&available_memory, 0, ULONGEST_MAX);
2921 make_cleanup (VEC_cleanup(mem_range_s), &available_memory);
2923 list_cleanup = make_cleanup_ui_out_list_begin_end (uiout, "memory");
2925 for (i = 0; VEC_iterate (mem_range_s, available_memory, i, r); i++)
2927 struct cleanup *cleanup_child;
2929 struct gdbarch *gdbarch = target_gdbarch ();
2931 cleanup_child = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
2933 ui_out_field_core_addr (uiout, "address", gdbarch, r->start);
2934 ui_out_field_int (uiout, "length", r->length);
2936 data = xmalloc (r->length);
2937 make_cleanup (xfree, data);
2939 if (memory_contents)
2941 if (target_read_memory (r->start, data, r->length) == 0)
2946 data_str = xmalloc (r->length * 2 + 1);
2947 make_cleanup (xfree, data_str);
2949 for (m = 0, p = data_str; m < r->length; ++m, p += 2)
2950 sprintf (p, "%02x", data[m]);
2951 ui_out_field_string (uiout, "contents", data_str);
2954 ui_out_field_skip (uiout, "contents");
2956 do_cleanups (cleanup_child);
2959 do_cleanups (list_cleanup);
2962 do_cleanups (old_chain);
2966 _initialize_mi_main (void)
2968 struct cmd_list_element *c;
2970 add_setshow_boolean_cmd ("mi-async", class_run,
2972 Set whether MI asynchronous mode is enabled."), _("\
2973 Show whether MI asynchronous mode is enabled."), _("\
2974 Tells GDB whether MI should be in asynchronous mode."),
2975 set_mi_async_command,
2976 show_mi_async_command,
2980 /* Alias old "target-async" to "mi-async". */
2981 c = add_alias_cmd ("target-async", "mi-async", class_run, 0, &setlist);
2982 deprecate_cmd (c, "set mi-async");
2983 c = add_alias_cmd ("target-async", "mi-async", class_run, 0, &showlist);
2984 deprecate_cmd (c, "show mi-async");