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"
27 #include "exceptions.h"
29 #include "gdbthread.h"
32 #include "mi-getopt.h"
33 #include "mi-console.h"
37 #include "event-loop.h"
38 #include "event-top.h"
39 #include "gdbcore.h" /* For write_memory(). */
45 #include "mi-common.h"
50 #include "splay-tree.h"
51 #include "tracepoint.h"
55 #include "extension.h"
60 #if defined HAVE_SYS_RESOURCE_H
61 #include <sys/resource.h>
75 struct ui_file *raw_stdout;
77 /* This is used to pass the current command timestamp down to
78 continuation routines. */
79 static struct mi_timestamp *current_command_ts;
81 static int do_timings = 0;
84 /* Few commands would like to know if options like --thread-group were
85 explicitly specified. This variable keeps the current parsed
86 command including all option, and make it possible. */
87 static struct mi_parse *current_context;
89 int running_result_record_printed = 1;
91 /* Flag indicating that the target has proceeded since the last
92 command was issued. */
95 extern void _initialize_mi_main (void);
96 static void mi_cmd_execute (struct mi_parse *parse);
98 static void mi_execute_cli_command (const char *cmd, int args_p,
100 static void mi_execute_async_cli_command (char *cli_command,
101 char **argv, int argc);
102 static int register_changed_p (int regnum, struct regcache *,
104 static void output_register (struct frame_info *, int regnum, int format,
105 int skip_unavailable);
107 /* Command implementations. FIXME: Is this libgdb? No. This is the MI
108 layer that calls libgdb. Any operation used in the below should be
111 static void timestamp (struct mi_timestamp *tv);
113 static void print_diff_now (struct mi_timestamp *start);
114 static void print_diff (struct mi_timestamp *start, struct mi_timestamp *end);
117 mi_cmd_gdb_exit (char *command, char **argv, int argc)
119 /* We have to print everything right here because we never return. */
121 fputs_unfiltered (current_token, raw_stdout);
122 fputs_unfiltered ("^exit\n", raw_stdout);
123 mi_out_put (current_uiout, raw_stdout);
124 gdb_flush (raw_stdout);
125 /* FIXME: The function called is not yet a formal libgdb function. */
126 quit_force (NULL, FROM_TTY);
130 mi_cmd_exec_next (char *command, char **argv, int argc)
132 /* FIXME: Should call a libgdb function, not a cli wrapper. */
133 if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
134 mi_execute_async_cli_command ("reverse-next", argv + 1, argc - 1);
136 mi_execute_async_cli_command ("next", argv, argc);
140 mi_cmd_exec_next_instruction (char *command, char **argv, int argc)
142 /* FIXME: Should call a libgdb function, not a cli wrapper. */
143 if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
144 mi_execute_async_cli_command ("reverse-nexti", argv + 1, argc - 1);
146 mi_execute_async_cli_command ("nexti", argv, argc);
150 mi_cmd_exec_step (char *command, char **argv, int argc)
152 /* FIXME: Should call a libgdb function, not a cli wrapper. */
153 if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
154 mi_execute_async_cli_command ("reverse-step", argv + 1, argc - 1);
156 mi_execute_async_cli_command ("step", argv, argc);
160 mi_cmd_exec_step_instruction (char *command, char **argv, int argc)
162 /* FIXME: Should call a libgdb function, not a cli wrapper. */
163 if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
164 mi_execute_async_cli_command ("reverse-stepi", argv + 1, argc - 1);
166 mi_execute_async_cli_command ("stepi", argv, argc);
170 mi_cmd_exec_finish (char *command, char **argv, int argc)
172 /* FIXME: Should call a libgdb function, not a cli wrapper. */
173 if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
174 mi_execute_async_cli_command ("reverse-finish", argv + 1, argc - 1);
176 mi_execute_async_cli_command ("finish", argv, argc);
180 mi_cmd_exec_return (char *command, char **argv, int argc)
182 /* This command doesn't really execute the target, it just pops the
183 specified number of frames. */
185 /* Call return_command with from_tty argument equal to 0 so as to
186 avoid being queried. */
187 return_command (*argv, 0);
189 /* Call return_command with from_tty argument equal to 0 so as to
190 avoid being queried. */
191 return_command (NULL, 0);
193 /* Because we have called return_command with from_tty = 0, we need
194 to print the frame here. */
195 print_stack_frame (get_selected_frame (NULL), 1, LOC_AND_ADDRESS, 1);
199 mi_cmd_exec_jump (char *args, char **argv, int argc)
201 /* FIXME: Should call a libgdb function, not a cli wrapper. */
202 mi_execute_async_cli_command ("jump", argv, argc);
206 proceed_thread (struct thread_info *thread, int pid)
208 if (!is_stopped (thread->ptid))
211 if (pid != 0 && ptid_get_pid (thread->ptid) != pid)
214 switch_to_thread (thread->ptid);
215 clear_proceed_status ();
216 proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT, 0);
220 proceed_thread_callback (struct thread_info *thread, void *arg)
222 int pid = *(int *)arg;
224 proceed_thread (thread, pid);
229 exec_continue (char **argv, int argc)
233 /* In non-stop mode, 'resume' always resumes a single thread.
234 Therefore, to resume all threads of the current inferior, or
235 all threads in all inferiors, we need to iterate over
238 See comment on infcmd.c:proceed_thread_callback for rationale. */
239 if (current_context->all || current_context->thread_group != -1)
242 struct cleanup *back_to = make_cleanup_restore_current_thread ();
244 if (!current_context->all)
247 = find_inferior_id (current_context->thread_group);
251 iterate_over_threads (proceed_thread_callback, &pid);
252 do_cleanups (back_to);
261 struct cleanup *back_to = make_cleanup_restore_integer (&sched_multi);
263 if (current_context->all)
270 /* In all-stop mode, -exec-continue traditionally resumed
271 either all threads, or one thread, depending on the
272 'scheduler-locking' variable. Let's continue to do the
276 do_cleanups (back_to);
281 exec_direction_forward (void *notused)
283 execution_direction = EXEC_FORWARD;
287 exec_reverse_continue (char **argv, int argc)
289 enum exec_direction_kind dir = execution_direction;
290 struct cleanup *old_chain;
292 if (dir == EXEC_REVERSE)
293 error (_("Already in reverse mode."));
295 if (!target_can_execute_reverse)
296 error (_("Target %s does not support this command."), target_shortname);
298 old_chain = make_cleanup (exec_direction_forward, NULL);
299 execution_direction = EXEC_REVERSE;
300 exec_continue (argv, argc);
301 do_cleanups (old_chain);
305 mi_cmd_exec_continue (char *command, char **argv, int argc)
307 if (argc > 0 && strcmp (argv[0], "--reverse") == 0)
308 exec_reverse_continue (argv + 1, argc - 1);
310 exec_continue (argv, argc);
314 interrupt_thread_callback (struct thread_info *thread, void *arg)
316 int pid = *(int *)arg;
318 if (!is_running (thread->ptid))
321 if (ptid_get_pid (thread->ptid) != pid)
324 target_stop (thread->ptid);
328 /* Interrupt the execution of the target. Note how we must play
329 around with the token variables, in order to display the current
330 token in the result of the interrupt command, and the previous
331 execution token when the target finally stops. See comments in
335 mi_cmd_exec_interrupt (char *command, char **argv, int argc)
337 /* In all-stop mode, everything stops, so we don't need to try
338 anything specific. */
341 interrupt_target_1 (0);
345 if (current_context->all)
347 /* This will interrupt all threads in all inferiors. */
348 interrupt_target_1 (1);
350 else if (current_context->thread_group != -1)
352 struct inferior *inf = find_inferior_id (current_context->thread_group);
354 iterate_over_threads (interrupt_thread_callback, &inf->pid);
358 /* Interrupt just the current thread -- either explicitly
359 specified via --thread or whatever was current before
360 MI command was sent. */
361 interrupt_target_1 (0);
365 /* Callback for iterate_over_inferiors which starts the execution
366 of the given inferior.
368 ARG is a pointer to an integer whose value, if non-zero, indicates
369 that the program should be stopped when reaching the main subprogram
370 (similar to what the CLI "start" command does). */
373 run_one_inferior (struct inferior *inf, void *arg)
375 int start_p = *(int *) arg;
376 const char *run_cmd = start_p ? "start" : "run";
380 if (inf->pid != ptid_get_pid (inferior_ptid))
382 struct thread_info *tp;
384 tp = any_thread_of_process (inf->pid);
386 error (_("Inferior has no threads."));
388 switch_to_thread (tp->ptid);
393 set_current_inferior (inf);
394 switch_to_thread (null_ptid);
395 set_current_program_space (inf->pspace);
397 mi_execute_cli_command (run_cmd, target_can_async_p (),
398 target_can_async_p () ? "&" : NULL);
403 mi_cmd_exec_run (char *command, char **argv, int argc)
408 /* Parse the command options. */
413 static const struct mi_opt opts[] =
415 {"-start", START_OPT, 0},
424 int opt = mi_getopt ("-exec-run", argc, argv, opts, &oind, &oarg);
428 switch ((enum opt) opt)
436 /* This command does not accept any argument. Make sure the user
437 did not provide any. */
439 error (_("Invalid argument: %s"), argv[oind]);
441 if (current_context->all)
443 struct cleanup *back_to = save_current_space_and_thread ();
445 iterate_over_inferiors (run_one_inferior, &start_p);
446 do_cleanups (back_to);
450 const char *run_cmd = start_p ? "start" : "run";
452 mi_execute_cli_command (run_cmd, target_can_async_p (),
453 target_can_async_p () ? "&" : NULL);
459 find_thread_of_process (struct thread_info *ti, void *p)
463 if (ptid_get_pid (ti->ptid) == pid && !is_exited (ti->ptid))
470 mi_cmd_target_detach (char *command, char **argv, int argc)
472 if (argc != 0 && argc != 1)
473 error (_("Usage: -target-detach [pid | thread-group]"));
477 struct thread_info *tp;
481 /* First see if we are dealing with a thread-group id. */
484 struct inferior *inf;
485 int id = strtoul (argv[0] + 1, &end, 0);
488 error (_("Invalid syntax of thread-group id '%s'"), argv[0]);
490 inf = find_inferior_id (id);
492 error (_("Non-existent thread-group id '%d'"), id);
498 /* We must be dealing with a pid. */
499 pid = strtol (argv[0], &end, 10);
502 error (_("Invalid identifier '%s'"), argv[0]);
505 /* Pick any thread in the desired process. Current
506 target_detach detaches from the parent of inferior_ptid. */
507 tp = iterate_over_threads (find_thread_of_process, &pid);
509 error (_("Thread group is empty"));
511 switch_to_thread (tp->ptid);
514 detach_command (NULL, 0);
518 mi_cmd_thread_select (char *command, char **argv, int argc)
521 char *mi_error_message;
524 error (_("-thread-select: USAGE: threadnum."));
526 rc = gdb_thread_select (current_uiout, argv[0], &mi_error_message);
528 if (rc == GDB_RC_FAIL)
530 make_cleanup (xfree, mi_error_message);
531 error ("%s", mi_error_message);
536 mi_cmd_thread_list_ids (char *command, char **argv, int argc)
539 char *mi_error_message;
542 error (_("-thread-list-ids: No arguments required."));
544 rc = gdb_list_thread_ids (current_uiout, &mi_error_message);
546 if (rc == GDB_RC_FAIL)
548 make_cleanup (xfree, mi_error_message);
549 error ("%s", mi_error_message);
554 mi_cmd_thread_info (char *command, char **argv, int argc)
556 if (argc != 0 && argc != 1)
557 error (_("Invalid MI command"));
559 print_thread_info (current_uiout, argv[0], -1);
562 struct collect_cores_data
570 collect_cores (struct thread_info *ti, void *xdata)
572 struct collect_cores_data *data = xdata;
574 if (ptid_get_pid (ti->ptid) == data->pid)
576 int core = target_core_of_thread (ti->ptid);
579 VEC_safe_push (int, data->cores, core);
586 unique (int *b, int *e)
596 struct print_one_inferior_data
599 VEC (int) *inferiors;
603 print_one_inferior (struct inferior *inferior, void *xdata)
605 struct print_one_inferior_data *top_data = xdata;
606 struct ui_out *uiout = current_uiout;
608 if (VEC_empty (int, top_data->inferiors)
609 || bsearch (&(inferior->pid), VEC_address (int, top_data->inferiors),
610 VEC_length (int, top_data->inferiors), sizeof (int),
611 compare_positive_ints))
613 struct collect_cores_data data;
614 struct cleanup *back_to
615 = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
617 ui_out_field_fmt (uiout, "id", "i%d", inferior->num);
618 ui_out_field_string (uiout, "type", "process");
619 if (inferior->pid != 0)
620 ui_out_field_int (uiout, "pid", inferior->pid);
622 if (inferior->pspace->pspace_exec_filename != NULL)
624 ui_out_field_string (uiout, "executable",
625 inferior->pspace->pspace_exec_filename);
629 if (inferior->pid != 0)
631 data.pid = inferior->pid;
632 iterate_over_threads (collect_cores, &data);
635 if (!VEC_empty (int, data.cores))
638 struct cleanup *back_to_2 =
639 make_cleanup_ui_out_list_begin_end (uiout, "cores");
641 qsort (VEC_address (int, data.cores),
642 VEC_length (int, data.cores), sizeof (int),
643 compare_positive_ints);
645 b = VEC_address (int, data.cores);
646 e = b + VEC_length (int, data.cores);
650 ui_out_field_int (uiout, NULL, *b);
652 do_cleanups (back_to_2);
655 if (top_data->recurse)
656 print_thread_info (uiout, NULL, inferior->pid);
658 do_cleanups (back_to);
664 /* Output a field named 'cores' with a list as the value. The
665 elements of the list are obtained by splitting 'cores' on
669 output_cores (struct ui_out *uiout, const char *field_name, const char *xcores)
671 struct cleanup *back_to = make_cleanup_ui_out_list_begin_end (uiout,
673 char *cores = xstrdup (xcores);
676 make_cleanup (xfree, cores);
678 for (p = strtok (p, ","); p; p = strtok (NULL, ","))
679 ui_out_field_string (uiout, NULL, p);
681 do_cleanups (back_to);
685 free_vector_of_ints (void *xvector)
687 VEC (int) **vector = xvector;
689 VEC_free (int, *vector);
693 do_nothing (splay_tree_key k)
698 free_vector_of_osdata_items (splay_tree_value xvalue)
700 VEC (osdata_item_s) *value = (VEC (osdata_item_s) *) xvalue;
702 /* We don't free the items itself, it will be done separately. */
703 VEC_free (osdata_item_s, value);
707 splay_tree_int_comparator (splay_tree_key xa, splay_tree_key xb)
716 free_splay_tree (void *xt)
719 splay_tree_delete (t);
723 list_available_thread_groups (VEC (int) *ids, int recurse)
726 struct osdata_item *item;
728 struct ui_out *uiout = current_uiout;
729 struct cleanup *cleanup;
731 /* This keeps a map from integer (pid) to VEC (struct osdata_item *)*
732 The vector contains information about all threads for the given pid.
733 This is assigned an initial value to avoid "may be used uninitialized"
735 splay_tree tree = NULL;
737 /* get_osdata will throw if it cannot return data. */
738 data = get_osdata ("processes");
739 cleanup = make_cleanup_osdata_free (data);
743 struct osdata *threads = get_osdata ("threads");
745 make_cleanup_osdata_free (threads);
746 tree = splay_tree_new (splay_tree_int_comparator,
748 free_vector_of_osdata_items);
749 make_cleanup (free_splay_tree, tree);
752 VEC_iterate (osdata_item_s, threads->items,
756 const char *pid = get_osdata_column (item, "pid");
757 int pid_i = strtoul (pid, NULL, 0);
758 VEC (osdata_item_s) *vec = 0;
760 splay_tree_node n = splay_tree_lookup (tree, pid_i);
763 VEC_safe_push (osdata_item_s, vec, item);
764 splay_tree_insert (tree, pid_i, (splay_tree_value)vec);
768 vec = (VEC (osdata_item_s) *) n->value;
769 VEC_safe_push (osdata_item_s, vec, item);
770 n->value = (splay_tree_value) vec;
775 make_cleanup_ui_out_list_begin_end (uiout, "groups");
778 VEC_iterate (osdata_item_s, data->items,
782 struct cleanup *back_to;
784 const char *pid = get_osdata_column (item, "pid");
785 const char *cmd = get_osdata_column (item, "command");
786 const char *user = get_osdata_column (item, "user");
787 const char *cores = get_osdata_column (item, "cores");
789 int pid_i = strtoul (pid, NULL, 0);
791 /* At present, the target will return all available processes
792 and if information about specific ones was required, we filter
793 undesired processes here. */
794 if (ids && bsearch (&pid_i, VEC_address (int, ids),
795 VEC_length (int, ids),
796 sizeof (int), compare_positive_ints) == NULL)
800 back_to = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
802 ui_out_field_fmt (uiout, "id", "%s", pid);
803 ui_out_field_string (uiout, "type", "process");
805 ui_out_field_string (uiout, "description", cmd);
807 ui_out_field_string (uiout, "user", user);
809 output_cores (uiout, "cores", cores);
813 splay_tree_node n = splay_tree_lookup (tree, pid_i);
816 VEC (osdata_item_s) *children = (VEC (osdata_item_s) *) n->value;
817 struct osdata_item *child;
820 make_cleanup_ui_out_list_begin_end (uiout, "threads");
823 VEC_iterate (osdata_item_s, children, ix_child, child);
826 struct cleanup *back_to_2 =
827 make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
828 const char *tid = get_osdata_column (child, "tid");
829 const char *tcore = get_osdata_column (child, "core");
831 ui_out_field_string (uiout, "id", tid);
833 ui_out_field_string (uiout, "core", tcore);
835 do_cleanups (back_to_2);
840 do_cleanups (back_to);
843 do_cleanups (cleanup);
847 mi_cmd_list_thread_groups (char *command, char **argv, int argc)
849 struct ui_out *uiout = current_uiout;
850 struct cleanup *back_to;
857 AVAILABLE_OPT, RECURSE_OPT
859 static const struct mi_opt opts[] =
861 {"-available", AVAILABLE_OPT, 0},
862 {"-recurse", RECURSE_OPT, 1},
871 int opt = mi_getopt ("-list-thread-groups", argc, argv, opts,
876 switch ((enum opt) opt)
882 if (strcmp (oarg, "0") == 0)
884 else if (strcmp (oarg, "1") == 0)
887 error (_("only '0' and '1' are valid values "
888 "for the '--recurse' option"));
893 for (; oind < argc; ++oind)
898 if (*(argv[oind]) != 'i')
899 error (_("invalid syntax of group id '%s'"), argv[oind]);
901 inf = strtoul (argv[oind] + 1, &end, 0);
904 error (_("invalid syntax of group id '%s'"), argv[oind]);
905 VEC_safe_push (int, ids, inf);
907 if (VEC_length (int, ids) > 1)
908 qsort (VEC_address (int, ids),
909 VEC_length (int, ids),
910 sizeof (int), compare_positive_ints);
912 back_to = make_cleanup (free_vector_of_ints, &ids);
916 list_available_thread_groups (ids, recurse);
918 else if (VEC_length (int, ids) == 1)
920 /* Local thread groups, single id. */
921 int id = *VEC_address (int, ids);
922 struct inferior *inf = find_inferior_id (id);
925 error (_("Non-existent thread group id '%d'"), id);
927 print_thread_info (uiout, NULL, inf->pid);
931 struct print_one_inferior_data data;
933 data.recurse = recurse;
934 data.inferiors = ids;
936 /* Local thread groups. Either no explicit ids -- and we
937 print everything, or several explicit ids. In both cases,
938 we print more than one group, and have to use 'groups'
939 as the top-level element. */
940 make_cleanup_ui_out_list_begin_end (uiout, "groups");
941 update_thread_list ();
942 iterate_over_inferiors (print_one_inferior, &data);
945 do_cleanups (back_to);
949 mi_cmd_data_list_register_names (char *command, char **argv, int argc)
951 struct gdbarch *gdbarch;
952 struct ui_out *uiout = current_uiout;
955 struct cleanup *cleanup;
957 /* Note that the test for a valid register must include checking the
958 gdbarch_register_name because gdbarch_num_regs may be allocated
959 for the union of the register sets within a family of related
960 processors. In this case, some entries of gdbarch_register_name
961 will change depending upon the particular processor being
964 gdbarch = get_current_arch ();
965 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
967 cleanup = make_cleanup_ui_out_list_begin_end (uiout, "register-names");
969 if (argc == 0) /* No args, just do all the regs. */
975 if (gdbarch_register_name (gdbarch, regnum) == NULL
976 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
977 ui_out_field_string (uiout, NULL, "");
979 ui_out_field_string (uiout, NULL,
980 gdbarch_register_name (gdbarch, regnum));
984 /* Else, list of register #s, just do listed regs. */
985 for (i = 0; i < argc; i++)
987 regnum = atoi (argv[i]);
988 if (regnum < 0 || regnum >= numregs)
989 error (_("bad register number"));
991 if (gdbarch_register_name (gdbarch, regnum) == NULL
992 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
993 ui_out_field_string (uiout, NULL, "");
995 ui_out_field_string (uiout, NULL,
996 gdbarch_register_name (gdbarch, regnum));
998 do_cleanups (cleanup);
1002 mi_cmd_data_list_changed_registers (char *command, char **argv, int argc)
1004 static struct regcache *this_regs = NULL;
1005 struct ui_out *uiout = current_uiout;
1006 struct regcache *prev_regs;
1007 struct gdbarch *gdbarch;
1008 int regnum, numregs, changed;
1010 struct cleanup *cleanup;
1012 /* The last time we visited this function, the current frame's
1013 register contents were saved in THIS_REGS. Move THIS_REGS over
1014 to PREV_REGS, and refresh THIS_REGS with the now-current register
1017 prev_regs = this_regs;
1018 this_regs = frame_save_as_regcache (get_selected_frame (NULL));
1019 cleanup = make_cleanup_regcache_xfree (prev_regs);
1021 /* Note that the test for a valid register must include checking the
1022 gdbarch_register_name because gdbarch_num_regs may be allocated
1023 for the union of the register sets within a family of related
1024 processors. In this case, some entries of gdbarch_register_name
1025 will change depending upon the particular processor being
1028 gdbarch = get_regcache_arch (this_regs);
1029 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
1031 make_cleanup_ui_out_list_begin_end (uiout, "changed-registers");
1035 /* No args, just do all the regs. */
1040 if (gdbarch_register_name (gdbarch, regnum) == NULL
1041 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
1043 changed = register_changed_p (regnum, prev_regs, this_regs);
1045 error (_("-data-list-changed-registers: "
1046 "Unable to read register contents."));
1048 ui_out_field_int (uiout, NULL, regnum);
1052 /* Else, list of register #s, just do listed regs. */
1053 for (i = 0; i < argc; i++)
1055 regnum = atoi (argv[i]);
1059 && gdbarch_register_name (gdbarch, regnum) != NULL
1060 && *gdbarch_register_name (gdbarch, regnum) != '\000')
1062 changed = register_changed_p (regnum, prev_regs, this_regs);
1064 error (_("-data-list-changed-registers: "
1065 "Unable to read register contents."));
1067 ui_out_field_int (uiout, NULL, regnum);
1070 error (_("bad register number"));
1072 do_cleanups (cleanup);
1076 register_changed_p (int regnum, struct regcache *prev_regs,
1077 struct regcache *this_regs)
1079 struct gdbarch *gdbarch = get_regcache_arch (this_regs);
1080 gdb_byte prev_buffer[MAX_REGISTER_SIZE];
1081 gdb_byte this_buffer[MAX_REGISTER_SIZE];
1082 enum register_status prev_status;
1083 enum register_status this_status;
1085 /* First time through or after gdbarch change consider all registers
1087 if (!prev_regs || get_regcache_arch (prev_regs) != gdbarch)
1090 /* Get register contents and compare. */
1091 prev_status = regcache_cooked_read (prev_regs, regnum, prev_buffer);
1092 this_status = regcache_cooked_read (this_regs, regnum, this_buffer);
1094 if (this_status != prev_status)
1096 else if (this_status == REG_VALID)
1097 return memcmp (prev_buffer, this_buffer,
1098 register_size (gdbarch, regnum)) != 0;
1103 /* Return a list of register number and value pairs. The valid
1104 arguments expected are: a letter indicating the format in which to
1105 display the registers contents. This can be one of: x
1106 (hexadecimal), d (decimal), N (natural), t (binary), o (octal), r
1107 (raw). After the format argument there can be a sequence of
1108 numbers, indicating which registers to fetch the content of. If
1109 the format is the only argument, a list of all the registers with
1110 their values is returned. */
1113 mi_cmd_data_list_register_values (char *command, char **argv, int argc)
1115 struct ui_out *uiout = current_uiout;
1116 struct frame_info *frame;
1117 struct gdbarch *gdbarch;
1118 int regnum, numregs, format;
1120 struct cleanup *list_cleanup;
1121 int skip_unavailable = 0;
1127 static const struct mi_opt opts[] =
1129 {"-skip-unavailable", SKIP_UNAVAILABLE, 0},
1133 /* Note that the test for a valid register must include checking the
1134 gdbarch_register_name because gdbarch_num_regs may be allocated
1135 for the union of the register sets within a family of related
1136 processors. In this case, some entries of gdbarch_register_name
1137 will change depending upon the particular processor being
1143 int opt = mi_getopt ("-data-list-register-values", argc, argv,
1144 opts, &oind, &oarg);
1148 switch ((enum opt) opt)
1150 case SKIP_UNAVAILABLE:
1151 skip_unavailable = 1;
1156 if (argc - oind < 1)
1157 error (_("-data-list-register-values: Usage: "
1158 "-data-list-register-values [--skip-unavailable] <format>"
1159 " [<regnum1>...<regnumN>]"));
1161 format = (int) argv[oind][0];
1163 frame = get_selected_frame (NULL);
1164 gdbarch = get_frame_arch (frame);
1165 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
1167 list_cleanup = make_cleanup_ui_out_list_begin_end (uiout, "register-values");
1169 if (argc - oind == 1)
1171 /* No args, beside the format: do all the regs. */
1176 if (gdbarch_register_name (gdbarch, regnum) == NULL
1177 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
1180 output_register (frame, regnum, format, skip_unavailable);
1184 /* Else, list of register #s, just do listed regs. */
1185 for (i = 1 + oind; i < argc; i++)
1187 regnum = atoi (argv[i]);
1191 && gdbarch_register_name (gdbarch, regnum) != NULL
1192 && *gdbarch_register_name (gdbarch, regnum) != '\000')
1193 output_register (frame, regnum, format, skip_unavailable);
1195 error (_("bad register number"));
1197 do_cleanups (list_cleanup);
1200 /* Output one register REGNUM's contents in the desired FORMAT. If
1201 SKIP_UNAVAILABLE is true, skip the register if it is
1205 output_register (struct frame_info *frame, int regnum, int format,
1206 int skip_unavailable)
1208 struct gdbarch *gdbarch = get_frame_arch (frame);
1209 struct ui_out *uiout = current_uiout;
1210 struct value *val = value_of_register (regnum, frame);
1211 struct cleanup *tuple_cleanup;
1212 struct value_print_options opts;
1213 struct ui_file *stb;
1215 if (skip_unavailable && !value_entirely_available (val))
1218 tuple_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1219 ui_out_field_int (uiout, "number", regnum);
1227 stb = mem_fileopen ();
1228 make_cleanup_ui_file_delete (stb);
1230 get_formatted_print_options (&opts, format);
1232 val_print (value_type (val),
1233 value_contents_for_printing (val),
1234 value_embedded_offset (val), 0,
1235 stb, 0, val, &opts, current_language);
1236 ui_out_field_stream (uiout, "value", stb);
1238 do_cleanups (tuple_cleanup);
1241 /* Write given values into registers. The registers and values are
1242 given as pairs. The corresponding MI command is
1243 -data-write-register-values <format>
1244 [<regnum1> <value1>...<regnumN> <valueN>] */
1246 mi_cmd_data_write_register_values (char *command, char **argv, int argc)
1248 struct regcache *regcache;
1249 struct gdbarch *gdbarch;
1252 /* Note that the test for a valid register must include checking the
1253 gdbarch_register_name because gdbarch_num_regs may be allocated
1254 for the union of the register sets within a family of related
1255 processors. In this case, some entries of gdbarch_register_name
1256 will change depending upon the particular processor being
1259 regcache = get_current_regcache ();
1260 gdbarch = get_regcache_arch (regcache);
1261 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
1264 error (_("-data-write-register-values: Usage: -data-write-register-"
1265 "values <format> [<regnum1> <value1>...<regnumN> <valueN>]"));
1267 if (!target_has_registers)
1268 error (_("-data-write-register-values: No registers."));
1271 error (_("-data-write-register-values: No regs and values specified."));
1274 error (_("-data-write-register-values: "
1275 "Regs and vals are not in pairs."));
1277 for (i = 1; i < argc; i = i + 2)
1279 int regnum = atoi (argv[i]);
1281 if (regnum >= 0 && regnum < numregs
1282 && gdbarch_register_name (gdbarch, regnum)
1283 && *gdbarch_register_name (gdbarch, regnum))
1287 /* Get the value as a number. */
1288 value = parse_and_eval_address (argv[i + 1]);
1290 /* Write it down. */
1291 regcache_cooked_write_signed (regcache, regnum, value);
1294 error (_("bad register number"));
1298 /* Evaluate the value of the argument. The argument is an
1299 expression. If the expression contains spaces it needs to be
1300 included in double quotes. */
1303 mi_cmd_data_evaluate_expression (char *command, char **argv, int argc)
1305 struct expression *expr;
1306 struct cleanup *old_chain;
1308 struct ui_file *stb;
1309 struct value_print_options opts;
1310 struct ui_out *uiout = current_uiout;
1312 stb = mem_fileopen ();
1313 old_chain = make_cleanup_ui_file_delete (stb);
1316 error (_("-data-evaluate-expression: "
1317 "Usage: -data-evaluate-expression expression"));
1319 expr = parse_expression (argv[0]);
1321 make_cleanup (free_current_contents, &expr);
1323 val = evaluate_expression (expr);
1325 /* Print the result of the expression evaluation. */
1326 get_user_print_options (&opts);
1328 common_val_print (val, stb, 0, &opts, current_language);
1330 ui_out_field_stream (uiout, "value", stb);
1332 do_cleanups (old_chain);
1335 /* This is the -data-read-memory command.
1337 ADDR: start address of data to be dumped.
1338 WORD-FORMAT: a char indicating format for the ``word''. See
1340 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
1341 NR_ROW: Number of rows.
1342 NR_COL: The number of colums (words per row).
1343 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
1344 ASCHAR for unprintable characters.
1346 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
1347 displayes them. Returns:
1349 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
1352 The number of bytes read is SIZE*ROW*COL. */
1355 mi_cmd_data_read_memory (char *command, char **argv, int argc)
1357 struct gdbarch *gdbarch = get_current_arch ();
1358 struct ui_out *uiout = current_uiout;
1359 struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
1361 long total_bytes, nr_cols, nr_rows;
1363 struct type *word_type;
1376 static const struct mi_opt opts[] =
1378 {"o", OFFSET_OPT, 1},
1384 int opt = mi_getopt ("-data-read-memory", argc, argv, opts,
1389 switch ((enum opt) opt)
1392 offset = atol (oarg);
1399 if (argc < 5 || argc > 6)
1400 error (_("-data-read-memory: Usage: "
1401 "ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR]."));
1403 /* Extract all the arguments. */
1405 /* Start address of the memory dump. */
1406 addr = parse_and_eval_address (argv[0]) + offset;
1407 /* The format character to use when displaying a memory word. See
1408 the ``x'' command. */
1409 word_format = argv[1][0];
1410 /* The size of the memory word. */
1411 word_size = atol (argv[2]);
1415 word_type = builtin_type (gdbarch)->builtin_int8;
1419 word_type = builtin_type (gdbarch)->builtin_int16;
1423 word_type = builtin_type (gdbarch)->builtin_int32;
1427 word_type = builtin_type (gdbarch)->builtin_int64;
1431 word_type = builtin_type (gdbarch)->builtin_int8;
1434 /* The number of rows. */
1435 nr_rows = atol (argv[3]);
1437 error (_("-data-read-memory: invalid number of rows."));
1439 /* Number of bytes per row. */
1440 nr_cols = atol (argv[4]);
1442 error (_("-data-read-memory: invalid number of columns."));
1444 /* The un-printable character when printing ascii. */
1450 /* Create a buffer and read it in. */
1451 total_bytes = word_size * nr_rows * nr_cols;
1452 mbuf = xcalloc (total_bytes, 1);
1453 make_cleanup (xfree, mbuf);
1455 /* Dispatch memory reads to the topmost target, not the flattened
1457 nr_bytes = target_read (current_target.beneath,
1458 TARGET_OBJECT_MEMORY, NULL, mbuf,
1461 error (_("Unable to read memory."));
1463 /* Output the header information. */
1464 ui_out_field_core_addr (uiout, "addr", gdbarch, addr);
1465 ui_out_field_int (uiout, "nr-bytes", nr_bytes);
1466 ui_out_field_int (uiout, "total-bytes", total_bytes);
1467 ui_out_field_core_addr (uiout, "next-row",
1468 gdbarch, addr + word_size * nr_cols);
1469 ui_out_field_core_addr (uiout, "prev-row",
1470 gdbarch, addr - word_size * nr_cols);
1471 ui_out_field_core_addr (uiout, "next-page", gdbarch, addr + total_bytes);
1472 ui_out_field_core_addr (uiout, "prev-page", gdbarch, addr - total_bytes);
1474 /* Build the result as a two dimentional table. */
1476 struct ui_file *stream;
1477 struct cleanup *cleanup_stream;
1481 stream = mem_fileopen ();
1482 cleanup_stream = make_cleanup_ui_file_delete (stream);
1484 make_cleanup_ui_out_list_begin_end (uiout, "memory");
1485 for (row = 0, row_byte = 0;
1487 row++, row_byte += nr_cols * word_size)
1491 struct cleanup *cleanup_tuple;
1492 struct cleanup *cleanup_list_data;
1493 struct value_print_options opts;
1495 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1496 ui_out_field_core_addr (uiout, "addr", gdbarch, addr + row_byte);
1497 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr +
1499 cleanup_list_data = make_cleanup_ui_out_list_begin_end (uiout, "data");
1500 get_formatted_print_options (&opts, word_format);
1501 for (col = 0, col_byte = row_byte;
1503 col++, col_byte += word_size)
1505 if (col_byte + word_size > nr_bytes)
1507 ui_out_field_string (uiout, NULL, "N/A");
1511 ui_file_rewind (stream);
1512 print_scalar_formatted (mbuf + col_byte, word_type, &opts,
1513 word_asize, stream);
1514 ui_out_field_stream (uiout, NULL, stream);
1517 do_cleanups (cleanup_list_data);
1522 ui_file_rewind (stream);
1523 for (byte = row_byte;
1524 byte < row_byte + word_size * nr_cols; byte++)
1526 if (byte >= nr_bytes)
1527 fputc_unfiltered ('X', stream);
1528 else if (mbuf[byte] < 32 || mbuf[byte] > 126)
1529 fputc_unfiltered (aschar, stream);
1531 fputc_unfiltered (mbuf[byte], stream);
1533 ui_out_field_stream (uiout, "ascii", stream);
1535 do_cleanups (cleanup_tuple);
1537 do_cleanups (cleanup_stream);
1539 do_cleanups (cleanups);
1543 mi_cmd_data_read_memory_bytes (char *command, char **argv, int argc)
1545 struct gdbarch *gdbarch = get_current_arch ();
1546 struct ui_out *uiout = current_uiout;
1547 struct cleanup *cleanups;
1550 memory_read_result_s *read_result;
1552 VEC(memory_read_result_s) *result;
1560 static const struct mi_opt opts[] =
1562 {"o", OFFSET_OPT, 1},
1568 int opt = mi_getopt ("-data-read-memory-bytes", argc, argv, opts,
1572 switch ((enum opt) opt)
1575 offset = atol (oarg);
1583 error (_("Usage: [ -o OFFSET ] ADDR LENGTH."));
1585 addr = parse_and_eval_address (argv[0]) + offset;
1586 length = atol (argv[1]);
1588 result = read_memory_robust (current_target.beneath, addr, length);
1590 cleanups = make_cleanup (free_memory_read_result_vector, result);
1592 if (VEC_length (memory_read_result_s, result) == 0)
1593 error (_("Unable to read memory."));
1595 make_cleanup_ui_out_list_begin_end (uiout, "memory");
1597 VEC_iterate (memory_read_result_s, result, ix, read_result);
1600 struct cleanup *t = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1604 ui_out_field_core_addr (uiout, "begin", gdbarch, read_result->begin);
1605 ui_out_field_core_addr (uiout, "offset", gdbarch, read_result->begin
1607 ui_out_field_core_addr (uiout, "end", gdbarch, read_result->end);
1609 data = xmalloc ((read_result->end - read_result->begin) * 2 + 1);
1611 for (i = 0, p = data;
1612 i < (read_result->end - read_result->begin);
1615 sprintf (p, "%02x", read_result->data[i]);
1617 ui_out_field_string (uiout, "contents", data);
1621 do_cleanups (cleanups);
1624 /* Implementation of the -data-write_memory command.
1626 COLUMN_OFFSET: optional argument. Must be preceded by '-o'. The
1627 offset from the beginning of the memory grid row where the cell to
1629 ADDR: start address of the row in the memory grid where the memory
1630 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
1631 the location to write to.
1632 FORMAT: a char indicating format for the ``word''. See
1634 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
1635 VALUE: value to be written into the memory address.
1637 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1642 mi_cmd_data_write_memory (char *command, char **argv, int argc)
1644 struct gdbarch *gdbarch = get_current_arch ();
1645 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1648 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1649 enough when using a compiler other than GCC. */
1652 struct cleanup *old_chain;
1660 static const struct mi_opt opts[] =
1662 {"o", OFFSET_OPT, 1},
1668 int opt = mi_getopt ("-data-write-memory", argc, argv, opts,
1673 switch ((enum opt) opt)
1676 offset = atol (oarg);
1684 error (_("-data-write-memory: Usage: "
1685 "[-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE."));
1687 /* Extract all the arguments. */
1688 /* Start address of the memory dump. */
1689 addr = parse_and_eval_address (argv[0]);
1690 /* The size of the memory word. */
1691 word_size = atol (argv[2]);
1693 /* Calculate the real address of the write destination. */
1694 addr += (offset * word_size);
1696 /* Get the value as a number. */
1697 value = parse_and_eval_address (argv[3]);
1698 /* Get the value into an array. */
1699 buffer = xmalloc (word_size);
1700 old_chain = make_cleanup (xfree, buffer);
1701 store_signed_integer (buffer, word_size, byte_order, value);
1702 /* Write it down to memory. */
1703 write_memory_with_notification (addr, buffer, word_size);
1704 /* Free the buffer. */
1705 do_cleanups (old_chain);
1708 /* Implementation of the -data-write-memory-bytes command.
1711 DATA: string of bytes to write at that address
1712 COUNT: number of bytes to be filled (decimal integer). */
1715 mi_cmd_data_write_memory_bytes (char *command, char **argv, int argc)
1721 size_t len, i, steps, remainder;
1723 struct cleanup *back_to;
1725 if (argc != 2 && argc != 3)
1726 error (_("Usage: ADDR DATA [COUNT]."));
1728 addr = parse_and_eval_address (argv[0]);
1730 if (strlen (cdata) % 2)
1731 error (_("Hex-encoded '%s' must have an even number of characters."),
1734 len = strlen (cdata)/2;
1736 count = strtoul (argv[2], NULL, 10);
1740 databuf = xmalloc (len * sizeof (gdb_byte));
1741 back_to = make_cleanup (xfree, databuf);
1743 for (i = 0; i < len; ++i)
1746 if (sscanf (cdata + i * 2, "%02x", &x) != 1)
1747 error (_("Invalid argument"));
1748 databuf[i] = (gdb_byte) x;
1753 /* Pattern is made of less bytes than count:
1754 repeat pattern to fill memory. */
1755 data = xmalloc (count);
1756 make_cleanup (xfree, data);
1758 steps = count / len;
1759 remainder = count % len;
1760 for (j = 0; j < steps; j++)
1761 memcpy (data + j * len, databuf, len);
1764 memcpy (data + steps * len, databuf, remainder);
1768 /* Pattern is longer than or equal to count:
1769 just copy len bytes. */
1773 write_memory_with_notification (addr, data, count);
1775 do_cleanups (back_to);
1779 mi_cmd_enable_timings (char *command, char **argv, int argc)
1785 if (strcmp (argv[0], "yes") == 0)
1787 else if (strcmp (argv[0], "no") == 0)
1798 error (_("-enable-timings: Usage: %s {yes|no}"), command);
1802 mi_cmd_list_features (char *command, char **argv, int argc)
1806 struct cleanup *cleanup = NULL;
1807 struct ui_out *uiout = current_uiout;
1809 cleanup = make_cleanup_ui_out_list_begin_end (uiout, "features");
1810 ui_out_field_string (uiout, NULL, "frozen-varobjs");
1811 ui_out_field_string (uiout, NULL, "pending-breakpoints");
1812 ui_out_field_string (uiout, NULL, "thread-info");
1813 ui_out_field_string (uiout, NULL, "data-read-memory-bytes");
1814 ui_out_field_string (uiout, NULL, "breakpoint-notifications");
1815 ui_out_field_string (uiout, NULL, "ada-task-info");
1816 ui_out_field_string (uiout, NULL, "language-option");
1817 ui_out_field_string (uiout, NULL, "info-gdb-mi-command");
1818 ui_out_field_string (uiout, NULL, "undefined-command-error-code");
1819 ui_out_field_string (uiout, NULL, "exec-run-start-option");
1821 if (ext_lang_initialized_p (get_ext_lang_defn (EXT_LANG_PYTHON)))
1822 ui_out_field_string (uiout, NULL, "python");
1824 do_cleanups (cleanup);
1828 error (_("-list-features should be passed no arguments"));
1832 mi_cmd_list_target_features (char *command, char **argv, int argc)
1836 struct cleanup *cleanup = NULL;
1837 struct ui_out *uiout = current_uiout;
1839 cleanup = make_cleanup_ui_out_list_begin_end (uiout, "features");
1840 if (target_can_async_p ())
1841 ui_out_field_string (uiout, NULL, "async");
1842 if (target_can_execute_reverse)
1843 ui_out_field_string (uiout, NULL, "reverse");
1845 do_cleanups (cleanup);
1849 error (_("-list-target-features should be passed no arguments"));
1853 mi_cmd_add_inferior (char *command, char **argv, int argc)
1855 struct inferior *inf;
1858 error (_("-add-inferior should be passed no arguments"));
1860 inf = add_inferior_with_spaces ();
1862 ui_out_field_fmt (current_uiout, "inferior", "i%d", inf->num);
1865 /* Callback used to find the first inferior other than the current
1869 get_other_inferior (struct inferior *inf, void *arg)
1871 if (inf == current_inferior ())
1878 mi_cmd_remove_inferior (char *command, char **argv, int argc)
1881 struct inferior *inf;
1884 error (_("-remove-inferior should be passed a single argument"));
1886 if (sscanf (argv[0], "i%d", &id) != 1)
1887 error (_("the thread group id is syntactically invalid"));
1889 inf = find_inferior_id (id);
1891 error (_("the specified thread group does not exist"));
1894 error (_("cannot remove an active inferior"));
1896 if (inf == current_inferior ())
1898 struct thread_info *tp = 0;
1899 struct inferior *new_inferior
1900 = iterate_over_inferiors (get_other_inferior, NULL);
1902 if (new_inferior == NULL)
1903 error (_("Cannot remove last inferior"));
1905 set_current_inferior (new_inferior);
1906 if (new_inferior->pid != 0)
1907 tp = any_thread_of_process (new_inferior->pid);
1908 switch_to_thread (tp ? tp->ptid : null_ptid);
1909 set_current_program_space (new_inferior->pspace);
1912 delete_inferior_1 (inf, 1 /* silent */);
1917 /* Execute a command within a safe environment.
1918 Return <0 for error; >=0 for ok.
1920 args->action will tell mi_execute_command what action
1921 to perfrom after the given command has executed (display/suppress
1922 prompt, display error). */
1925 captured_mi_execute_command (struct ui_out *uiout, struct mi_parse *context)
1927 struct cleanup *cleanup;
1930 current_command_ts = context->cmd_start;
1932 current_token = xstrdup (context->token);
1933 cleanup = make_cleanup (free_current_contents, ¤t_token);
1935 running_result_record_printed = 0;
1937 switch (context->op)
1940 /* A MI command was read from the input stream. */
1942 /* FIXME: gdb_???? */
1943 fprintf_unfiltered (raw_stdout, " token=`%s' command=`%s' args=`%s'\n",
1944 context->token, context->command, context->args);
1946 mi_cmd_execute (context);
1948 /* Print the result if there were no errors.
1950 Remember that on the way out of executing a command, you have
1951 to directly use the mi_interp's uiout, since the command
1952 could have reset the interpreter, in which case the current
1953 uiout will most likely crash in the mi_out_* routines. */
1954 if (!running_result_record_printed)
1956 fputs_unfiltered (context->token, raw_stdout);
1957 /* There's no particularly good reason why target-connect results
1958 in not ^done. Should kill ^connected for MI3. */
1959 fputs_unfiltered (strcmp (context->command, "target-select") == 0
1960 ? "^connected" : "^done", raw_stdout);
1961 mi_out_put (uiout, raw_stdout);
1962 mi_out_rewind (uiout);
1963 mi_print_timing_maybe ();
1964 fputs_unfiltered ("\n", raw_stdout);
1967 /* The command does not want anything to be printed. In that
1968 case, the command probably should not have written anything
1969 to uiout, but in case it has written something, discard it. */
1970 mi_out_rewind (uiout);
1977 /* A CLI command was read from the input stream. */
1978 /* This "feature" will be removed as soon as we have a
1979 complete set of mi commands. */
1980 /* Echo the command on the console. */
1981 fprintf_unfiltered (gdb_stdlog, "%s\n", context->command);
1982 /* Call the "console" interpreter. */
1983 argv[0] = "console";
1984 argv[1] = context->command;
1985 mi_cmd_interpreter_exec ("-interpreter-exec", argv, 2);
1987 /* If we changed interpreters, DON'T print out anything. */
1988 if (current_interp_named_p (INTERP_MI)
1989 || current_interp_named_p (INTERP_MI1)
1990 || current_interp_named_p (INTERP_MI2)
1991 || current_interp_named_p (INTERP_MI3))
1993 if (!running_result_record_printed)
1995 fputs_unfiltered (context->token, raw_stdout);
1996 fputs_unfiltered ("^done", raw_stdout);
1997 mi_out_put (uiout, raw_stdout);
1998 mi_out_rewind (uiout);
1999 mi_print_timing_maybe ();
2000 fputs_unfiltered ("\n", raw_stdout);
2003 mi_out_rewind (uiout);
2009 do_cleanups (cleanup);
2012 /* Print a gdb exception to the MI output stream. */
2015 mi_print_exception (const char *token, struct gdb_exception exception)
2017 fputs_unfiltered (token, raw_stdout);
2018 fputs_unfiltered ("^error,msg=\"", raw_stdout);
2019 if (exception.message == NULL)
2020 fputs_unfiltered ("unknown error", raw_stdout);
2022 fputstr_unfiltered (exception.message, '"', raw_stdout);
2023 fputs_unfiltered ("\"", raw_stdout);
2025 switch (exception.error)
2027 case UNDEFINED_COMMAND_ERROR:
2028 fputs_unfiltered (",code=\"undefined-command\"", raw_stdout);
2032 fputs_unfiltered ("\n", raw_stdout);
2036 mi_execute_command (const char *cmd, int from_tty)
2039 struct mi_parse *command = NULL;
2040 volatile struct gdb_exception exception;
2042 /* This is to handle EOF (^D). We just quit gdb. */
2043 /* FIXME: we should call some API function here. */
2045 quit_force (NULL, from_tty);
2047 target_log_command (cmd);
2049 TRY_CATCH (exception, RETURN_MASK_ALL)
2051 command = mi_parse (cmd, &token);
2053 if (exception.reason < 0)
2055 mi_print_exception (token, exception);
2060 volatile struct gdb_exception result;
2061 ptid_t previous_ptid = inferior_ptid;
2063 command->token = token;
2067 command->cmd_start = (struct mi_timestamp *)
2068 xmalloc (sizeof (struct mi_timestamp));
2069 timestamp (command->cmd_start);
2072 TRY_CATCH (result, RETURN_MASK_ALL)
2074 captured_mi_execute_command (current_uiout, command);
2076 if (result.reason < 0)
2078 /* The command execution failed and error() was called
2080 mi_print_exception (command->token, result);
2081 mi_out_rewind (current_uiout);
2084 bpstat_do_actions ();
2086 if (/* The notifications are only output when the top-level
2087 interpreter (specified on the command line) is MI. */
2088 ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ()))
2089 /* Don't try report anything if there are no threads --
2090 the program is dead. */
2091 && thread_count () != 0
2092 /* -thread-select explicitly changes thread. If frontend uses that
2093 internally, we don't want to emit =thread-selected, since
2094 =thread-selected is supposed to indicate user's intentions. */
2095 && strcmp (command->command, "thread-select") != 0)
2097 struct mi_interp *mi = top_level_interpreter_data ();
2098 int report_change = 0;
2100 if (command->thread == -1)
2102 report_change = (!ptid_equal (previous_ptid, null_ptid)
2103 && !ptid_equal (inferior_ptid, previous_ptid)
2104 && !ptid_equal (inferior_ptid, null_ptid));
2106 else if (!ptid_equal (inferior_ptid, null_ptid))
2108 struct thread_info *ti = inferior_thread ();
2110 report_change = (ti->num != command->thread);
2115 struct thread_info *ti = inferior_thread ();
2117 target_terminal_ours ();
2118 fprintf_unfiltered (mi->event_channel,
2119 "thread-selected,id=\"%d\"",
2121 gdb_flush (mi->event_channel);
2125 mi_parse_free (command);
2130 mi_cmd_execute (struct mi_parse *parse)
2132 struct cleanup *cleanup;
2133 enum language saved_language;
2135 cleanup = prepare_execute_command ();
2137 if (parse->all && parse->thread_group != -1)
2138 error (_("Cannot specify --thread-group together with --all"));
2140 if (parse->all && parse->thread != -1)
2141 error (_("Cannot specify --thread together with --all"));
2143 if (parse->thread_group != -1 && parse->thread != -1)
2144 error (_("Cannot specify --thread together with --thread-group"));
2146 if (parse->frame != -1 && parse->thread == -1)
2147 error (_("Cannot specify --frame without --thread"));
2149 if (parse->thread_group != -1)
2151 struct inferior *inf = find_inferior_id (parse->thread_group);
2152 struct thread_info *tp = 0;
2155 error (_("Invalid thread group for the --thread-group option"));
2157 set_current_inferior (inf);
2158 /* This behaviour means that if --thread-group option identifies
2159 an inferior with multiple threads, then a random one will be
2160 picked. This is not a problem -- frontend should always
2161 provide --thread if it wishes to operate on a specific
2164 tp = any_live_thread_of_process (inf->pid);
2165 switch_to_thread (tp ? tp->ptid : null_ptid);
2166 set_current_program_space (inf->pspace);
2169 if (parse->thread != -1)
2171 struct thread_info *tp = find_thread_id (parse->thread);
2174 error (_("Invalid thread id: %d"), parse->thread);
2176 if (is_exited (tp->ptid))
2177 error (_("Thread id: %d has terminated"), parse->thread);
2179 switch_to_thread (tp->ptid);
2182 if (parse->frame != -1)
2184 struct frame_info *fid;
2185 int frame = parse->frame;
2187 fid = find_relative_frame (get_current_frame (), &frame);
2189 /* find_relative_frame was successful */
2192 error (_("Invalid frame id: %d"), frame);
2195 if (parse->language != language_unknown)
2197 make_cleanup_restore_current_language ();
2198 set_language (parse->language);
2201 current_context = parse;
2203 if (parse->cmd->suppress_notification != NULL)
2205 make_cleanup_restore_integer (parse->cmd->suppress_notification);
2206 *parse->cmd->suppress_notification = 1;
2209 if (parse->cmd->argv_func != NULL)
2211 parse->cmd->argv_func (parse->command, parse->argv, parse->argc);
2213 else if (parse->cmd->cli.cmd != 0)
2215 /* FIXME: DELETE THIS. */
2216 /* The operation is still implemented by a cli command. */
2217 /* Must be a synchronous one. */
2218 mi_execute_cli_command (parse->cmd->cli.cmd, parse->cmd->cli.args_p,
2223 /* FIXME: DELETE THIS. */
2224 struct ui_file *stb;
2226 stb = mem_fileopen ();
2228 fputs_unfiltered ("Undefined mi command: ", stb);
2229 fputstr_unfiltered (parse->command, '"', stb);
2230 fputs_unfiltered (" (missing implementation)", stb);
2232 make_cleanup_ui_file_delete (stb);
2235 do_cleanups (cleanup);
2238 /* FIXME: This is just a hack so we can get some extra commands going.
2239 We don't want to channel things through the CLI, but call libgdb directly.
2240 Use only for synchronous commands. */
2243 mi_execute_cli_command (const char *cmd, int args_p, const char *args)
2247 struct cleanup *old_cleanups;
2251 run = xstrprintf ("%s %s", cmd, args);
2253 run = xstrdup (cmd);
2255 /* FIXME: gdb_???? */
2256 fprintf_unfiltered (gdb_stdout, "cli=%s run=%s\n",
2258 old_cleanups = make_cleanup (xfree, run);
2259 execute_command (run, 0 /* from_tty */ );
2260 do_cleanups (old_cleanups);
2266 mi_execute_async_cli_command (char *cli_command, char **argv, int argc)
2268 struct cleanup *old_cleanups;
2271 if (target_can_async_p ())
2272 run = xstrprintf ("%s %s&", cli_command, argc ? *argv : "");
2274 run = xstrprintf ("%s %s", cli_command, argc ? *argv : "");
2275 old_cleanups = make_cleanup (xfree, run);
2277 execute_command (run, 0 /* from_tty */ );
2279 /* Do this before doing any printing. It would appear that some
2280 print code leaves garbage around in the buffer. */
2281 do_cleanups (old_cleanups);
2285 mi_load_progress (const char *section_name,
2286 unsigned long sent_so_far,
2287 unsigned long total_section,
2288 unsigned long total_sent,
2289 unsigned long grand_total)
2291 struct timeval time_now, delta, update_threshold;
2292 static struct timeval last_update;
2293 static char *previous_sect_name = NULL;
2295 struct ui_out *saved_uiout;
2296 struct ui_out *uiout;
2298 /* This function is called through deprecated_show_load_progress
2299 which means uiout may not be correct. Fix it for the duration
2300 of this function. */
2301 saved_uiout = current_uiout;
2303 if (current_interp_named_p (INTERP_MI)
2304 || current_interp_named_p (INTERP_MI2))
2305 current_uiout = mi_out_new (2);
2306 else if (current_interp_named_p (INTERP_MI1))
2307 current_uiout = mi_out_new (1);
2308 else if (current_interp_named_p (INTERP_MI3))
2309 current_uiout = mi_out_new (3);
2313 uiout = current_uiout;
2315 update_threshold.tv_sec = 0;
2316 update_threshold.tv_usec = 500000;
2317 gettimeofday (&time_now, NULL);
2319 delta.tv_usec = time_now.tv_usec - last_update.tv_usec;
2320 delta.tv_sec = time_now.tv_sec - last_update.tv_sec;
2322 if (delta.tv_usec < 0)
2325 delta.tv_usec += 1000000L;
2328 new_section = (previous_sect_name ?
2329 strcmp (previous_sect_name, section_name) : 1);
2332 struct cleanup *cleanup_tuple;
2334 xfree (previous_sect_name);
2335 previous_sect_name = xstrdup (section_name);
2338 fputs_unfiltered (current_token, raw_stdout);
2339 fputs_unfiltered ("+download", raw_stdout);
2340 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
2341 ui_out_field_string (uiout, "section", section_name);
2342 ui_out_field_int (uiout, "section-size", total_section);
2343 ui_out_field_int (uiout, "total-size", grand_total);
2344 do_cleanups (cleanup_tuple);
2345 mi_out_put (uiout, raw_stdout);
2346 fputs_unfiltered ("\n", raw_stdout);
2347 gdb_flush (raw_stdout);
2350 if (delta.tv_sec >= update_threshold.tv_sec &&
2351 delta.tv_usec >= update_threshold.tv_usec)
2353 struct cleanup *cleanup_tuple;
2355 last_update.tv_sec = time_now.tv_sec;
2356 last_update.tv_usec = time_now.tv_usec;
2358 fputs_unfiltered (current_token, raw_stdout);
2359 fputs_unfiltered ("+download", raw_stdout);
2360 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
2361 ui_out_field_string (uiout, "section", section_name);
2362 ui_out_field_int (uiout, "section-sent", sent_so_far);
2363 ui_out_field_int (uiout, "section-size", total_section);
2364 ui_out_field_int (uiout, "total-sent", total_sent);
2365 ui_out_field_int (uiout, "total-size", grand_total);
2366 do_cleanups (cleanup_tuple);
2367 mi_out_put (uiout, raw_stdout);
2368 fputs_unfiltered ("\n", raw_stdout);
2369 gdb_flush (raw_stdout);
2373 current_uiout = saved_uiout;
2377 timestamp (struct mi_timestamp *tv)
2379 gettimeofday (&tv->wallclock, NULL);
2380 #ifdef HAVE_GETRUSAGE
2381 getrusage (RUSAGE_SELF, &rusage);
2382 tv->utime.tv_sec = rusage.ru_utime.tv_sec;
2383 tv->utime.tv_usec = rusage.ru_utime.tv_usec;
2384 tv->stime.tv_sec = rusage.ru_stime.tv_sec;
2385 tv->stime.tv_usec = rusage.ru_stime.tv_usec;
2388 long usec = get_run_time ();
2390 tv->utime.tv_sec = usec/1000000L;
2391 tv->utime.tv_usec = usec - 1000000L*tv->utime.tv_sec;
2392 tv->stime.tv_sec = 0;
2393 tv->stime.tv_usec = 0;
2399 print_diff_now (struct mi_timestamp *start)
2401 struct mi_timestamp now;
2404 print_diff (start, &now);
2408 mi_print_timing_maybe (void)
2410 /* If the command is -enable-timing then do_timings may be true
2411 whilst current_command_ts is not initialized. */
2412 if (do_timings && current_command_ts)
2413 print_diff_now (current_command_ts);
2417 timeval_diff (struct timeval start, struct timeval end)
2419 return ((end.tv_sec - start.tv_sec) * 1000000L)
2420 + (end.tv_usec - start.tv_usec);
2424 print_diff (struct mi_timestamp *start, struct mi_timestamp *end)
2428 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
2429 timeval_diff (start->wallclock, end->wallclock) / 1000000.0,
2430 timeval_diff (start->utime, end->utime) / 1000000.0,
2431 timeval_diff (start->stime, end->stime) / 1000000.0);
2435 mi_cmd_trace_define_variable (char *command, char **argv, int argc)
2437 struct expression *expr;
2438 LONGEST initval = 0;
2439 struct trace_state_variable *tsv;
2442 if (argc != 1 && argc != 2)
2443 error (_("Usage: -trace-define-variable VARIABLE [VALUE]"));
2447 error (_("Name of trace variable should start with '$'"));
2449 validate_trace_state_variable_name (name);
2451 tsv = find_trace_state_variable (name);
2453 tsv = create_trace_state_variable (name);
2456 initval = value_as_long (parse_and_eval (argv[1]));
2458 tsv->initial_value = initval;
2462 mi_cmd_trace_list_variables (char *command, char **argv, int argc)
2465 error (_("-trace-list-variables: no arguments allowed"));
2467 tvariables_info_1 ();
2471 mi_cmd_trace_find (char *command, char **argv, int argc)
2476 error (_("trace selection mode is required"));
2480 if (strcmp (mode, "none") == 0)
2482 tfind_1 (tfind_number, -1, 0, 0, 0);
2486 if (current_trace_status ()->running)
2487 error (_("May not look at trace frames while trace is running."));
2489 if (strcmp (mode, "frame-number") == 0)
2492 error (_("frame number is required"));
2493 tfind_1 (tfind_number, atoi (argv[1]), 0, 0, 0);
2495 else if (strcmp (mode, "tracepoint-number") == 0)
2498 error (_("tracepoint number is required"));
2499 tfind_1 (tfind_tp, atoi (argv[1]), 0, 0, 0);
2501 else if (strcmp (mode, "pc") == 0)
2504 error (_("PC is required"));
2505 tfind_1 (tfind_pc, 0, parse_and_eval_address (argv[1]), 0, 0);
2507 else if (strcmp (mode, "pc-inside-range") == 0)
2510 error (_("Start and end PC are required"));
2511 tfind_1 (tfind_range, 0, parse_and_eval_address (argv[1]),
2512 parse_and_eval_address (argv[2]), 0);
2514 else if (strcmp (mode, "pc-outside-range") == 0)
2517 error (_("Start and end PC are required"));
2518 tfind_1 (tfind_outside, 0, parse_and_eval_address (argv[1]),
2519 parse_and_eval_address (argv[2]), 0);
2521 else if (strcmp (mode, "line") == 0)
2523 struct symtabs_and_lines sals;
2524 struct symtab_and_line sal;
2525 static CORE_ADDR start_pc, end_pc;
2526 struct cleanup *back_to;
2529 error (_("Line is required"));
2531 sals = decode_line_with_current_source (argv[1],
2532 DECODE_LINE_FUNFIRSTLINE);
2533 back_to = make_cleanup (xfree, sals.sals);
2537 if (sal.symtab == 0)
2538 error (_("Could not find the specified line"));
2540 if (sal.line > 0 && find_line_pc_range (sal, &start_pc, &end_pc))
2541 tfind_1 (tfind_range, 0, start_pc, end_pc - 1, 0);
2543 error (_("Could not find the specified line"));
2545 do_cleanups (back_to);
2548 error (_("Invalid mode '%s'"), mode);
2550 if (has_stack_frames () || get_traceframe_number () >= 0)
2551 print_stack_frame (get_selected_frame (NULL), 1, LOC_AND_ADDRESS, 1);
2555 mi_cmd_trace_save (char *command, char **argv, int argc)
2557 int target_saves = 0;
2558 int generate_ctf = 0;
2565 TARGET_SAVE_OPT, CTF_OPT
2567 static const struct mi_opt opts[] =
2569 {"r", TARGET_SAVE_OPT, 0},
2570 {"ctf", CTF_OPT, 0},
2576 int opt = mi_getopt ("-trace-save", argc, argv, opts,
2581 switch ((enum opt) opt)
2583 case TARGET_SAVE_OPT:
2591 filename = argv[oind];
2594 trace_save_ctf (filename, target_saves);
2596 trace_save_tfile (filename, target_saves);
2600 mi_cmd_trace_start (char *command, char **argv, int argc)
2602 start_tracing (NULL);
2606 mi_cmd_trace_status (char *command, char **argv, int argc)
2608 trace_status_mi (0);
2612 mi_cmd_trace_stop (char *command, char **argv, int argc)
2614 stop_tracing (NULL);
2615 trace_status_mi (1);
2618 /* Implement the "-ada-task-info" command. */
2621 mi_cmd_ada_task_info (char *command, char **argv, int argc)
2623 if (argc != 0 && argc != 1)
2624 error (_("Invalid MI command"));
2626 print_ada_task_info (current_uiout, argv[0], current_inferior ());
2629 /* Print EXPRESSION according to VALUES. */
2632 print_variable_or_computed (char *expression, enum print_values values)
2634 struct expression *expr;
2635 struct cleanup *old_chain;
2637 struct ui_file *stb;
2638 struct value_print_options opts;
2640 struct ui_out *uiout = current_uiout;
2642 stb = mem_fileopen ();
2643 old_chain = make_cleanup_ui_file_delete (stb);
2645 expr = parse_expression (expression);
2647 make_cleanup (free_current_contents, &expr);
2649 if (values == PRINT_SIMPLE_VALUES)
2650 val = evaluate_type (expr);
2652 val = evaluate_expression (expr);
2654 if (values != PRINT_NO_VALUES)
2655 make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
2656 ui_out_field_string (uiout, "name", expression);
2660 case PRINT_SIMPLE_VALUES:
2661 type = check_typedef (value_type (val));
2662 type_print (value_type (val), "", stb, -1);
2663 ui_out_field_stream (uiout, "type", stb);
2664 if (TYPE_CODE (type) != TYPE_CODE_ARRAY
2665 && TYPE_CODE (type) != TYPE_CODE_STRUCT
2666 && TYPE_CODE (type) != TYPE_CODE_UNION)
2668 struct value_print_options opts;
2670 get_no_prettyformat_print_options (&opts);
2672 common_val_print (val, stb, 0, &opts, current_language);
2673 ui_out_field_stream (uiout, "value", stb);
2676 case PRINT_ALL_VALUES:
2678 struct value_print_options opts;
2680 get_no_prettyformat_print_options (&opts);
2682 common_val_print (val, stb, 0, &opts, current_language);
2683 ui_out_field_stream (uiout, "value", stb);
2688 do_cleanups (old_chain);
2691 /* Implement the "-trace-frame-collected" command. */
2694 mi_cmd_trace_frame_collected (char *command, char **argv, int argc)
2696 struct cleanup *old_chain;
2697 struct bp_location *tloc;
2699 struct collection_list *clist;
2700 struct collection_list tracepoint_list, stepping_list;
2701 struct traceframe_info *tinfo;
2703 int var_print_values = PRINT_ALL_VALUES;
2704 int comp_print_values = PRINT_ALL_VALUES;
2705 int registers_format = 'x';
2706 int memory_contents = 0;
2707 struct ui_out *uiout = current_uiout;
2715 static const struct mi_opt opts[] =
2717 {"-var-print-values", VAR_PRINT_VALUES, 1},
2718 {"-comp-print-values", COMP_PRINT_VALUES, 1},
2719 {"-registers-format", REGISTERS_FORMAT, 1},
2720 {"-memory-contents", MEMORY_CONTENTS, 0},
2727 int opt = mi_getopt ("-trace-frame-collected", argc, argv, opts,
2731 switch ((enum opt) opt)
2733 case VAR_PRINT_VALUES:
2734 var_print_values = mi_parse_print_values (oarg);
2736 case COMP_PRINT_VALUES:
2737 comp_print_values = mi_parse_print_values (oarg);
2739 case REGISTERS_FORMAT:
2740 registers_format = oarg[0];
2741 case MEMORY_CONTENTS:
2742 memory_contents = 1;
2748 error (_("Usage: -trace-frame-collected "
2749 "[--var-print-values PRINT_VALUES] "
2750 "[--comp-print-values PRINT_VALUES] "
2751 "[--registers-format FORMAT]"
2752 "[--memory-contents]"));
2754 /* This throws an error is not inspecting a trace frame. */
2755 tloc = get_traceframe_location (&stepping_frame);
2757 /* This command only makes sense for the current frame, not the
2759 old_chain = make_cleanup_restore_current_thread ();
2760 select_frame (get_current_frame ());
2762 encode_actions_and_make_cleanup (tloc, &tracepoint_list,
2766 clist = &stepping_list;
2768 clist = &tracepoint_list;
2770 tinfo = get_traceframe_info ();
2772 /* Explicitly wholly collected variables. */
2774 struct cleanup *list_cleanup;
2778 list_cleanup = make_cleanup_ui_out_list_begin_end (uiout,
2779 "explicit-variables");
2780 for (i = 0; VEC_iterate (char_ptr, clist->wholly_collected, i, p); i++)
2781 print_variable_or_computed (p, var_print_values);
2782 do_cleanups (list_cleanup);
2785 /* Computed expressions. */
2787 struct cleanup *list_cleanup;
2792 = make_cleanup_ui_out_list_begin_end (uiout,
2793 "computed-expressions");
2794 for (i = 0; VEC_iterate (char_ptr, clist->computed, i, p); i++)
2795 print_variable_or_computed (p, comp_print_values);
2796 do_cleanups (list_cleanup);
2799 /* Registers. Given pseudo-registers, and that some architectures
2800 (like MIPS) actually hide the raw registers, we don't go through
2801 the trace frame info, but instead consult the register cache for
2802 register availability. */
2804 struct cleanup *list_cleanup;
2805 struct frame_info *frame;
2806 struct gdbarch *gdbarch;
2810 list_cleanup = make_cleanup_ui_out_list_begin_end (uiout, "registers");
2812 frame = get_selected_frame (NULL);
2813 gdbarch = get_frame_arch (frame);
2814 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
2816 for (regnum = 0; regnum < numregs; regnum++)
2818 if (gdbarch_register_name (gdbarch, regnum) == NULL
2819 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
2822 output_register (frame, regnum, registers_format, 1);
2825 do_cleanups (list_cleanup);
2828 /* Trace state variables. */
2830 struct cleanup *list_cleanup;
2835 list_cleanup = make_cleanup_ui_out_list_begin_end (uiout, "tvars");
2838 make_cleanup (free_current_contents, &tsvname);
2840 for (i = 0; VEC_iterate (int, tinfo->tvars, i, tvar); i++)
2842 struct cleanup *cleanup_child;
2843 struct trace_state_variable *tsv;
2845 tsv = find_trace_state_variable_by_number (tvar);
2847 cleanup_child = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
2851 tsvname = xrealloc (tsvname, strlen (tsv->name) + 2);
2853 strcpy (tsvname + 1, tsv->name);
2854 ui_out_field_string (uiout, "name", tsvname);
2856 tsv->value_known = target_get_trace_state_variable_value (tsv->number,
2858 ui_out_field_int (uiout, "current", tsv->value);
2862 ui_out_field_skip (uiout, "name");
2863 ui_out_field_skip (uiout, "current");
2866 do_cleanups (cleanup_child);
2869 do_cleanups (list_cleanup);
2874 struct cleanup *list_cleanup;
2875 VEC(mem_range_s) *available_memory = NULL;
2876 struct mem_range *r;
2879 traceframe_available_memory (&available_memory, 0, ULONGEST_MAX);
2880 make_cleanup (VEC_cleanup(mem_range_s), &available_memory);
2882 list_cleanup = make_cleanup_ui_out_list_begin_end (uiout, "memory");
2884 for (i = 0; VEC_iterate (mem_range_s, available_memory, i, r); i++)
2886 struct cleanup *cleanup_child;
2888 struct gdbarch *gdbarch = target_gdbarch ();
2890 cleanup_child = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
2892 ui_out_field_core_addr (uiout, "address", gdbarch, r->start);
2893 ui_out_field_int (uiout, "length", r->length);
2895 data = xmalloc (r->length);
2896 make_cleanup (xfree, data);
2898 if (memory_contents)
2900 if (target_read_memory (r->start, data, r->length) == 0)
2905 data_str = xmalloc (r->length * 2 + 1);
2906 make_cleanup (xfree, data_str);
2908 for (m = 0, p = data_str; m < r->length; ++m, p += 2)
2909 sprintf (p, "%02x", data[m]);
2910 ui_out_field_string (uiout, "contents", data_str);
2913 ui_out_field_skip (uiout, "contents");
2915 do_cleanups (cleanup_child);
2918 do_cleanups (list_cleanup);
2921 do_cleanups (old_chain);