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"
61 #if defined HAVE_SYS_RESOURCE_H
62 #include <sys/resource.h>
76 struct ui_file *raw_stdout;
78 /* This is used to pass the current command timestamp down to
79 continuation routines. */
80 static struct mi_timestamp *current_command_ts;
82 static int do_timings = 0;
85 /* Few commands would like to know if options like --thread-group were
86 explicitly specified. This variable keeps the current parsed
87 command including all option, and make it possible. */
88 static struct mi_parse *current_context;
90 int running_result_record_printed = 1;
92 /* Flag indicating that the target has proceeded since the last
93 command was issued. */
96 extern void _initialize_mi_main (void);
97 static void mi_cmd_execute (struct mi_parse *parse);
99 static void mi_execute_cli_command (const char *cmd, int args_p,
101 static void mi_execute_async_cli_command (char *cli_command,
102 char **argv, int argc);
103 static int register_changed_p (int regnum, struct regcache *,
105 static void output_register (struct frame_info *, int regnum, int format,
106 int skip_unavailable);
108 /* Command implementations. FIXME: Is this libgdb? No. This is the MI
109 layer that calls libgdb. Any operation used in the below should be
112 static void timestamp (struct mi_timestamp *tv);
114 static void print_diff_now (struct mi_timestamp *start);
115 static void print_diff (struct mi_timestamp *start, struct mi_timestamp *end);
118 mi_cmd_gdb_exit (char *command, char **argv, int argc)
120 /* We have to print everything right here because we never return. */
122 fputs_unfiltered (current_token, raw_stdout);
123 fputs_unfiltered ("^exit\n", raw_stdout);
124 mi_out_put (current_uiout, raw_stdout);
125 gdb_flush (raw_stdout);
126 /* FIXME: The function called is not yet a formal libgdb function. */
127 quit_force (NULL, FROM_TTY);
131 mi_cmd_exec_next (char *command, char **argv, int argc)
133 /* FIXME: Should call a libgdb function, not a cli wrapper. */
134 if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
135 mi_execute_async_cli_command ("reverse-next", argv + 1, argc - 1);
137 mi_execute_async_cli_command ("next", argv, argc);
141 mi_cmd_exec_next_instruction (char *command, char **argv, int argc)
143 /* FIXME: Should call a libgdb function, not a cli wrapper. */
144 if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
145 mi_execute_async_cli_command ("reverse-nexti", argv + 1, argc - 1);
147 mi_execute_async_cli_command ("nexti", argv, argc);
151 mi_cmd_exec_step (char *command, char **argv, int argc)
153 /* FIXME: Should call a libgdb function, not a cli wrapper. */
154 if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
155 mi_execute_async_cli_command ("reverse-step", argv + 1, argc - 1);
157 mi_execute_async_cli_command ("step", argv, argc);
161 mi_cmd_exec_step_instruction (char *command, char **argv, int argc)
163 /* FIXME: Should call a libgdb function, not a cli wrapper. */
164 if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
165 mi_execute_async_cli_command ("reverse-stepi", argv + 1, argc - 1);
167 mi_execute_async_cli_command ("stepi", argv, argc);
171 mi_cmd_exec_finish (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-finish", argv + 1, argc - 1);
177 mi_execute_async_cli_command ("finish", argv, argc);
181 mi_cmd_exec_return (char *command, char **argv, int argc)
183 /* This command doesn't really execute the target, it just pops the
184 specified number of frames. */
186 /* Call return_command with from_tty argument equal to 0 so as to
187 avoid being queried. */
188 return_command (*argv, 0);
190 /* Call return_command with from_tty argument equal to 0 so as to
191 avoid being queried. */
192 return_command (NULL, 0);
194 /* Because we have called return_command with from_tty = 0, we need
195 to print the frame here. */
196 print_stack_frame (get_selected_frame (NULL), 1, LOC_AND_ADDRESS, 1);
200 mi_cmd_exec_jump (char *args, char **argv, int argc)
202 /* FIXME: Should call a libgdb function, not a cli wrapper. */
203 mi_execute_async_cli_command ("jump", argv, argc);
207 proceed_thread (struct thread_info *thread, int pid)
209 if (!is_stopped (thread->ptid))
212 if (pid != 0 && ptid_get_pid (thread->ptid) != pid)
215 switch_to_thread (thread->ptid);
216 clear_proceed_status ();
217 proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT, 0);
221 proceed_thread_callback (struct thread_info *thread, void *arg)
223 int pid = *(int *)arg;
225 proceed_thread (thread, pid);
230 exec_continue (char **argv, int argc)
234 /* In non-stop mode, 'resume' always resumes a single thread.
235 Therefore, to resume all threads of the current inferior, or
236 all threads in all inferiors, we need to iterate over
239 See comment on infcmd.c:proceed_thread_callback for rationale. */
240 if (current_context->all || current_context->thread_group != -1)
243 struct cleanup *back_to = make_cleanup_restore_current_thread ();
245 if (!current_context->all)
248 = find_inferior_id (current_context->thread_group);
252 iterate_over_threads (proceed_thread_callback, &pid);
253 do_cleanups (back_to);
262 struct cleanup *back_to = make_cleanup_restore_integer (&sched_multi);
264 if (current_context->all)
271 /* In all-stop mode, -exec-continue traditionally resumed
272 either all threads, or one thread, depending on the
273 'scheduler-locking' variable. Let's continue to do the
277 do_cleanups (back_to);
282 exec_direction_forward (void *notused)
284 execution_direction = EXEC_FORWARD;
288 exec_reverse_continue (char **argv, int argc)
290 enum exec_direction_kind dir = execution_direction;
291 struct cleanup *old_chain;
293 if (dir == EXEC_REVERSE)
294 error (_("Already in reverse mode."));
296 if (!target_can_execute_reverse)
297 error (_("Target %s does not support this command."), target_shortname);
299 old_chain = make_cleanup (exec_direction_forward, NULL);
300 execution_direction = EXEC_REVERSE;
301 exec_continue (argv, argc);
302 do_cleanups (old_chain);
306 mi_cmd_exec_continue (char *command, char **argv, int argc)
308 if (argc > 0 && strcmp (argv[0], "--reverse") == 0)
309 exec_reverse_continue (argv + 1, argc - 1);
311 exec_continue (argv, argc);
315 interrupt_thread_callback (struct thread_info *thread, void *arg)
317 int pid = *(int *)arg;
319 if (!is_running (thread->ptid))
322 if (ptid_get_pid (thread->ptid) != pid)
325 target_stop (thread->ptid);
329 /* Interrupt the execution of the target. Note how we must play
330 around with the token variables, in order to display the current
331 token in the result of the interrupt command, and the previous
332 execution token when the target finally stops. See comments in
336 mi_cmd_exec_interrupt (char *command, char **argv, int argc)
338 /* In all-stop mode, everything stops, so we don't need to try
339 anything specific. */
342 interrupt_target_1 (0);
346 if (current_context->all)
348 /* This will interrupt all threads in all inferiors. */
349 interrupt_target_1 (1);
351 else if (current_context->thread_group != -1)
353 struct inferior *inf = find_inferior_id (current_context->thread_group);
355 iterate_over_threads (interrupt_thread_callback, &inf->pid);
359 /* Interrupt just the current thread -- either explicitly
360 specified via --thread or whatever was current before
361 MI command was sent. */
362 interrupt_target_1 (0);
366 /* Callback for iterate_over_inferiors which starts the execution
367 of the given inferior.
369 ARG is a pointer to an integer whose value, if non-zero, indicates
370 that the program should be stopped when reaching the main subprogram
371 (similar to what the CLI "start" command does). */
374 run_one_inferior (struct inferior *inf, void *arg)
376 int start_p = *(int *) arg;
377 const char *run_cmd = start_p ? "start" : "run";
381 if (inf->pid != ptid_get_pid (inferior_ptid))
383 struct thread_info *tp;
385 tp = any_thread_of_process (inf->pid);
387 error (_("Inferior has no threads."));
389 switch_to_thread (tp->ptid);
394 set_current_inferior (inf);
395 switch_to_thread (null_ptid);
396 set_current_program_space (inf->pspace);
398 mi_execute_cli_command (run_cmd, target_can_async_p (),
399 target_can_async_p () ? "&" : NULL);
404 mi_cmd_exec_run (char *command, char **argv, int argc)
409 /* Parse the command options. */
414 static const struct mi_opt opts[] =
416 {"-start", START_OPT, 0},
425 int opt = mi_getopt ("-exec-run", argc, argv, opts, &oind, &oarg);
429 switch ((enum opt) opt)
437 /* This command does not accept any argument. Make sure the user
438 did not provide any. */
440 error (_("Invalid argument: %s"), argv[oind]);
442 if (current_context->all)
444 struct cleanup *back_to = save_current_space_and_thread ();
446 iterate_over_inferiors (run_one_inferior, &start_p);
447 do_cleanups (back_to);
451 const char *run_cmd = start_p ? "start" : "run";
453 mi_execute_cli_command (run_cmd, target_can_async_p (),
454 target_can_async_p () ? "&" : NULL);
460 find_thread_of_process (struct thread_info *ti, void *p)
464 if (ptid_get_pid (ti->ptid) == pid && !is_exited (ti->ptid))
471 mi_cmd_target_detach (char *command, char **argv, int argc)
473 if (argc != 0 && argc != 1)
474 error (_("Usage: -target-detach [pid | thread-group]"));
478 struct thread_info *tp;
482 /* First see if we are dealing with a thread-group id. */
485 struct inferior *inf;
486 int id = strtoul (argv[0] + 1, &end, 0);
489 error (_("Invalid syntax of thread-group id '%s'"), argv[0]);
491 inf = find_inferior_id (id);
493 error (_("Non-existent thread-group id '%d'"), id);
499 /* We must be dealing with a pid. */
500 pid = strtol (argv[0], &end, 10);
503 error (_("Invalid identifier '%s'"), argv[0]);
506 /* Pick any thread in the desired process. Current
507 target_detach detaches from the parent of inferior_ptid. */
508 tp = iterate_over_threads (find_thread_of_process, &pid);
510 error (_("Thread group is empty"));
512 switch_to_thread (tp->ptid);
515 detach_command (NULL, 0);
519 mi_cmd_thread_select (char *command, char **argv, int argc)
522 char *mi_error_message;
525 error (_("-thread-select: USAGE: threadnum."));
527 rc = gdb_thread_select (current_uiout, argv[0], &mi_error_message);
529 if (rc == GDB_RC_FAIL)
531 make_cleanup (xfree, mi_error_message);
532 error ("%s", mi_error_message);
537 mi_cmd_thread_list_ids (char *command, char **argv, int argc)
540 char *mi_error_message;
543 error (_("-thread-list-ids: No arguments required."));
545 rc = gdb_list_thread_ids (current_uiout, &mi_error_message);
547 if (rc == GDB_RC_FAIL)
549 make_cleanup (xfree, mi_error_message);
550 error ("%s", mi_error_message);
555 mi_cmd_thread_info (char *command, char **argv, int argc)
557 if (argc != 0 && argc != 1)
558 error (_("Invalid MI command"));
560 print_thread_info (current_uiout, argv[0], -1);
563 struct collect_cores_data
571 collect_cores (struct thread_info *ti, void *xdata)
573 struct collect_cores_data *data = xdata;
575 if (ptid_get_pid (ti->ptid) == data->pid)
577 int core = target_core_of_thread (ti->ptid);
580 VEC_safe_push (int, data->cores, core);
587 unique (int *b, int *e)
597 struct print_one_inferior_data
600 VEC (int) *inferiors;
604 print_one_inferior (struct inferior *inferior, void *xdata)
606 struct print_one_inferior_data *top_data = xdata;
607 struct ui_out *uiout = current_uiout;
609 if (VEC_empty (int, top_data->inferiors)
610 || bsearch (&(inferior->pid), VEC_address (int, top_data->inferiors),
611 VEC_length (int, top_data->inferiors), sizeof (int),
612 compare_positive_ints))
614 struct collect_cores_data data;
615 struct cleanup *back_to
616 = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
618 ui_out_field_fmt (uiout, "id", "i%d", inferior->num);
619 ui_out_field_string (uiout, "type", "process");
620 if (inferior->pid != 0)
621 ui_out_field_int (uiout, "pid", inferior->pid);
623 if (inferior->pspace->pspace_exec_filename != NULL)
625 ui_out_field_string (uiout, "executable",
626 inferior->pspace->pspace_exec_filename);
630 if (inferior->pid != 0)
632 data.pid = inferior->pid;
633 iterate_over_threads (collect_cores, &data);
636 if (!VEC_empty (int, data.cores))
639 struct cleanup *back_to_2 =
640 make_cleanup_ui_out_list_begin_end (uiout, "cores");
642 qsort (VEC_address (int, data.cores),
643 VEC_length (int, data.cores), sizeof (int),
644 compare_positive_ints);
646 b = VEC_address (int, data.cores);
647 e = b + VEC_length (int, data.cores);
651 ui_out_field_int (uiout, NULL, *b);
653 do_cleanups (back_to_2);
656 if (top_data->recurse)
657 print_thread_info (uiout, NULL, inferior->pid);
659 do_cleanups (back_to);
665 /* Output a field named 'cores' with a list as the value. The
666 elements of the list are obtained by splitting 'cores' on
670 output_cores (struct ui_out *uiout, const char *field_name, const char *xcores)
672 struct cleanup *back_to = make_cleanup_ui_out_list_begin_end (uiout,
674 char *cores = xstrdup (xcores);
677 make_cleanup (xfree, cores);
679 for (p = strtok (p, ","); p; p = strtok (NULL, ","))
680 ui_out_field_string (uiout, NULL, p);
682 do_cleanups (back_to);
686 free_vector_of_ints (void *xvector)
688 VEC (int) **vector = xvector;
690 VEC_free (int, *vector);
694 do_nothing (splay_tree_key k)
699 free_vector_of_osdata_items (splay_tree_value xvalue)
701 VEC (osdata_item_s) *value = (VEC (osdata_item_s) *) xvalue;
703 /* We don't free the items itself, it will be done separately. */
704 VEC_free (osdata_item_s, value);
708 splay_tree_int_comparator (splay_tree_key xa, splay_tree_key xb)
717 free_splay_tree (void *xt)
720 splay_tree_delete (t);
724 list_available_thread_groups (VEC (int) *ids, int recurse)
727 struct osdata_item *item;
729 struct ui_out *uiout = current_uiout;
730 struct cleanup *cleanup;
732 /* This keeps a map from integer (pid) to VEC (struct osdata_item *)*
733 The vector contains information about all threads for the given pid.
734 This is assigned an initial value to avoid "may be used uninitialized"
736 splay_tree tree = NULL;
738 /* get_osdata will throw if it cannot return data. */
739 data = get_osdata ("processes");
740 cleanup = make_cleanup_osdata_free (data);
744 struct osdata *threads = get_osdata ("threads");
746 make_cleanup_osdata_free (threads);
747 tree = splay_tree_new (splay_tree_int_comparator,
749 free_vector_of_osdata_items);
750 make_cleanup (free_splay_tree, tree);
753 VEC_iterate (osdata_item_s, threads->items,
757 const char *pid = get_osdata_column (item, "pid");
758 int pid_i = strtoul (pid, NULL, 0);
759 VEC (osdata_item_s) *vec = 0;
761 splay_tree_node n = splay_tree_lookup (tree, pid_i);
764 VEC_safe_push (osdata_item_s, vec, item);
765 splay_tree_insert (tree, pid_i, (splay_tree_value)vec);
769 vec = (VEC (osdata_item_s) *) n->value;
770 VEC_safe_push (osdata_item_s, vec, item);
771 n->value = (splay_tree_value) vec;
776 make_cleanup_ui_out_list_begin_end (uiout, "groups");
779 VEC_iterate (osdata_item_s, data->items,
783 struct cleanup *back_to;
785 const char *pid = get_osdata_column (item, "pid");
786 const char *cmd = get_osdata_column (item, "command");
787 const char *user = get_osdata_column (item, "user");
788 const char *cores = get_osdata_column (item, "cores");
790 int pid_i = strtoul (pid, NULL, 0);
792 /* At present, the target will return all available processes
793 and if information about specific ones was required, we filter
794 undesired processes here. */
795 if (ids && bsearch (&pid_i, VEC_address (int, ids),
796 VEC_length (int, ids),
797 sizeof (int), compare_positive_ints) == NULL)
801 back_to = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
803 ui_out_field_fmt (uiout, "id", "%s", pid);
804 ui_out_field_string (uiout, "type", "process");
806 ui_out_field_string (uiout, "description", cmd);
808 ui_out_field_string (uiout, "user", user);
810 output_cores (uiout, "cores", cores);
814 splay_tree_node n = splay_tree_lookup (tree, pid_i);
817 VEC (osdata_item_s) *children = (VEC (osdata_item_s) *) n->value;
818 struct osdata_item *child;
821 make_cleanup_ui_out_list_begin_end (uiout, "threads");
824 VEC_iterate (osdata_item_s, children, ix_child, child);
827 struct cleanup *back_to_2 =
828 make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
829 const char *tid = get_osdata_column (child, "tid");
830 const char *tcore = get_osdata_column (child, "core");
832 ui_out_field_string (uiout, "id", tid);
834 ui_out_field_string (uiout, "core", tcore);
836 do_cleanups (back_to_2);
841 do_cleanups (back_to);
844 do_cleanups (cleanup);
848 mi_cmd_list_thread_groups (char *command, char **argv, int argc)
850 struct ui_out *uiout = current_uiout;
851 struct cleanup *back_to;
858 AVAILABLE_OPT, RECURSE_OPT
860 static const struct mi_opt opts[] =
862 {"-available", AVAILABLE_OPT, 0},
863 {"-recurse", RECURSE_OPT, 1},
872 int opt = mi_getopt ("-list-thread-groups", argc, argv, opts,
877 switch ((enum opt) opt)
883 if (strcmp (oarg, "0") == 0)
885 else if (strcmp (oarg, "1") == 0)
888 error (_("only '0' and '1' are valid values "
889 "for the '--recurse' option"));
894 for (; oind < argc; ++oind)
899 if (*(argv[oind]) != 'i')
900 error (_("invalid syntax of group id '%s'"), argv[oind]);
902 inf = strtoul (argv[oind] + 1, &end, 0);
905 error (_("invalid syntax of group id '%s'"), argv[oind]);
906 VEC_safe_push (int, ids, inf);
908 if (VEC_length (int, ids) > 1)
909 qsort (VEC_address (int, ids),
910 VEC_length (int, ids),
911 sizeof (int), compare_positive_ints);
913 back_to = make_cleanup (free_vector_of_ints, &ids);
917 list_available_thread_groups (ids, recurse);
919 else if (VEC_length (int, ids) == 1)
921 /* Local thread groups, single id. */
922 int id = *VEC_address (int, ids);
923 struct inferior *inf = find_inferior_id (id);
926 error (_("Non-existent thread group id '%d'"), id);
928 print_thread_info (uiout, NULL, inf->pid);
932 struct print_one_inferior_data data;
934 data.recurse = recurse;
935 data.inferiors = ids;
937 /* Local thread groups. Either no explicit ids -- and we
938 print everything, or several explicit ids. In both cases,
939 we print more than one group, and have to use 'groups'
940 as the top-level element. */
941 make_cleanup_ui_out_list_begin_end (uiout, "groups");
942 update_thread_list ();
943 iterate_over_inferiors (print_one_inferior, &data);
946 do_cleanups (back_to);
950 mi_cmd_data_list_register_names (char *command, char **argv, int argc)
952 struct gdbarch *gdbarch;
953 struct ui_out *uiout = current_uiout;
956 struct cleanup *cleanup;
958 /* Note that the test for a valid register must include checking the
959 gdbarch_register_name because gdbarch_num_regs may be allocated
960 for the union of the register sets within a family of related
961 processors. In this case, some entries of gdbarch_register_name
962 will change depending upon the particular processor being
965 gdbarch = get_current_arch ();
966 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
968 cleanup = make_cleanup_ui_out_list_begin_end (uiout, "register-names");
970 if (argc == 0) /* No args, just do all the regs. */
976 if (gdbarch_register_name (gdbarch, regnum) == NULL
977 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
978 ui_out_field_string (uiout, NULL, "");
980 ui_out_field_string (uiout, NULL,
981 gdbarch_register_name (gdbarch, regnum));
985 /* Else, list of register #s, just do listed regs. */
986 for (i = 0; i < argc; i++)
988 regnum = atoi (argv[i]);
989 if (regnum < 0 || regnum >= numregs)
990 error (_("bad register number"));
992 if (gdbarch_register_name (gdbarch, regnum) == NULL
993 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
994 ui_out_field_string (uiout, NULL, "");
996 ui_out_field_string (uiout, NULL,
997 gdbarch_register_name (gdbarch, regnum));
999 do_cleanups (cleanup);
1003 mi_cmd_data_list_changed_registers (char *command, char **argv, int argc)
1005 static struct regcache *this_regs = NULL;
1006 struct ui_out *uiout = current_uiout;
1007 struct regcache *prev_regs;
1008 struct gdbarch *gdbarch;
1009 int regnum, numregs, changed;
1011 struct cleanup *cleanup;
1013 /* The last time we visited this function, the current frame's
1014 register contents were saved in THIS_REGS. Move THIS_REGS over
1015 to PREV_REGS, and refresh THIS_REGS with the now-current register
1018 prev_regs = this_regs;
1019 this_regs = frame_save_as_regcache (get_selected_frame (NULL));
1020 cleanup = make_cleanup_regcache_xfree (prev_regs);
1022 /* Note that the test for a valid register must include checking the
1023 gdbarch_register_name because gdbarch_num_regs may be allocated
1024 for the union of the register sets within a family of related
1025 processors. In this case, some entries of gdbarch_register_name
1026 will change depending upon the particular processor being
1029 gdbarch = get_regcache_arch (this_regs);
1030 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
1032 make_cleanup_ui_out_list_begin_end (uiout, "changed-registers");
1036 /* No args, just do all the regs. */
1041 if (gdbarch_register_name (gdbarch, regnum) == NULL
1042 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
1044 changed = register_changed_p (regnum, prev_regs, this_regs);
1046 error (_("-data-list-changed-registers: "
1047 "Unable to read register contents."));
1049 ui_out_field_int (uiout, NULL, regnum);
1053 /* Else, list of register #s, just do listed regs. */
1054 for (i = 0; i < argc; i++)
1056 regnum = atoi (argv[i]);
1060 && gdbarch_register_name (gdbarch, regnum) != NULL
1061 && *gdbarch_register_name (gdbarch, regnum) != '\000')
1063 changed = register_changed_p (regnum, prev_regs, this_regs);
1065 error (_("-data-list-changed-registers: "
1066 "Unable to read register contents."));
1068 ui_out_field_int (uiout, NULL, regnum);
1071 error (_("bad register number"));
1073 do_cleanups (cleanup);
1077 register_changed_p (int regnum, struct regcache *prev_regs,
1078 struct regcache *this_regs)
1080 struct gdbarch *gdbarch = get_regcache_arch (this_regs);
1081 gdb_byte prev_buffer[MAX_REGISTER_SIZE];
1082 gdb_byte this_buffer[MAX_REGISTER_SIZE];
1083 enum register_status prev_status;
1084 enum register_status this_status;
1086 /* First time through or after gdbarch change consider all registers
1088 if (!prev_regs || get_regcache_arch (prev_regs) != gdbarch)
1091 /* Get register contents and compare. */
1092 prev_status = regcache_cooked_read (prev_regs, regnum, prev_buffer);
1093 this_status = regcache_cooked_read (this_regs, regnum, this_buffer);
1095 if (this_status != prev_status)
1097 else if (this_status == REG_VALID)
1098 return memcmp (prev_buffer, this_buffer,
1099 register_size (gdbarch, regnum)) != 0;
1104 /* Return a list of register number and value pairs. The valid
1105 arguments expected are: a letter indicating the format in which to
1106 display the registers contents. This can be one of: x
1107 (hexadecimal), d (decimal), N (natural), t (binary), o (octal), r
1108 (raw). After the format argument there can be a sequence of
1109 numbers, indicating which registers to fetch the content of. If
1110 the format is the only argument, a list of all the registers with
1111 their values is returned. */
1114 mi_cmd_data_list_register_values (char *command, char **argv, int argc)
1116 struct ui_out *uiout = current_uiout;
1117 struct frame_info *frame;
1118 struct gdbarch *gdbarch;
1119 int regnum, numregs, format;
1121 struct cleanup *list_cleanup;
1122 int skip_unavailable = 0;
1128 static const struct mi_opt opts[] =
1130 {"-skip-unavailable", SKIP_UNAVAILABLE, 0},
1134 /* Note that the test for a valid register must include checking the
1135 gdbarch_register_name because gdbarch_num_regs may be allocated
1136 for the union of the register sets within a family of related
1137 processors. In this case, some entries of gdbarch_register_name
1138 will change depending upon the particular processor being
1144 int opt = mi_getopt ("-data-list-register-values", argc, argv,
1145 opts, &oind, &oarg);
1149 switch ((enum opt) opt)
1151 case SKIP_UNAVAILABLE:
1152 skip_unavailable = 1;
1157 if (argc - oind < 1)
1158 error (_("-data-list-register-values: Usage: "
1159 "-data-list-register-values [--skip-unavailable] <format>"
1160 " [<regnum1>...<regnumN>]"));
1162 format = (int) argv[oind][0];
1164 frame = get_selected_frame (NULL);
1165 gdbarch = get_frame_arch (frame);
1166 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
1168 list_cleanup = make_cleanup_ui_out_list_begin_end (uiout, "register-values");
1170 if (argc - oind == 1)
1172 /* No args, beside the format: do all the regs. */
1177 if (gdbarch_register_name (gdbarch, regnum) == NULL
1178 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
1181 output_register (frame, regnum, format, skip_unavailable);
1185 /* Else, list of register #s, just do listed regs. */
1186 for (i = 1 + oind; i < argc; i++)
1188 regnum = atoi (argv[i]);
1192 && gdbarch_register_name (gdbarch, regnum) != NULL
1193 && *gdbarch_register_name (gdbarch, regnum) != '\000')
1194 output_register (frame, regnum, format, skip_unavailable);
1196 error (_("bad register number"));
1198 do_cleanups (list_cleanup);
1201 /* Output one register REGNUM's contents in the desired FORMAT. If
1202 SKIP_UNAVAILABLE is true, skip the register if it is
1206 output_register (struct frame_info *frame, int regnum, int format,
1207 int skip_unavailable)
1209 struct gdbarch *gdbarch = get_frame_arch (frame);
1210 struct ui_out *uiout = current_uiout;
1211 struct value *val = value_of_register (regnum, frame);
1212 struct cleanup *tuple_cleanup;
1213 struct value_print_options opts;
1214 struct ui_file *stb;
1216 if (skip_unavailable && !value_entirely_available (val))
1219 tuple_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1220 ui_out_field_int (uiout, "number", regnum);
1228 stb = mem_fileopen ();
1229 make_cleanup_ui_file_delete (stb);
1231 get_formatted_print_options (&opts, format);
1233 val_print (value_type (val),
1234 value_contents_for_printing (val),
1235 value_embedded_offset (val), 0,
1236 stb, 0, val, &opts, current_language);
1237 ui_out_field_stream (uiout, "value", stb);
1239 do_cleanups (tuple_cleanup);
1242 /* Write given values into registers. The registers and values are
1243 given as pairs. The corresponding MI command is
1244 -data-write-register-values <format>
1245 [<regnum1> <value1>...<regnumN> <valueN>] */
1247 mi_cmd_data_write_register_values (char *command, char **argv, int argc)
1249 struct regcache *regcache;
1250 struct gdbarch *gdbarch;
1253 /* Note that the test for a valid register must include checking the
1254 gdbarch_register_name because gdbarch_num_regs may be allocated
1255 for the union of the register sets within a family of related
1256 processors. In this case, some entries of gdbarch_register_name
1257 will change depending upon the particular processor being
1260 regcache = get_current_regcache ();
1261 gdbarch = get_regcache_arch (regcache);
1262 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
1265 error (_("-data-write-register-values: Usage: -data-write-register-"
1266 "values <format> [<regnum1> <value1>...<regnumN> <valueN>]"));
1268 if (!target_has_registers)
1269 error (_("-data-write-register-values: No registers."));
1272 error (_("-data-write-register-values: No regs and values specified."));
1275 error (_("-data-write-register-values: "
1276 "Regs and vals are not in pairs."));
1278 for (i = 1; i < argc; i = i + 2)
1280 int regnum = atoi (argv[i]);
1282 if (regnum >= 0 && regnum < numregs
1283 && gdbarch_register_name (gdbarch, regnum)
1284 && *gdbarch_register_name (gdbarch, regnum))
1288 /* Get the value as a number. */
1289 value = parse_and_eval_address (argv[i + 1]);
1291 /* Write it down. */
1292 regcache_cooked_write_signed (regcache, regnum, value);
1295 error (_("bad register number"));
1299 /* Evaluate the value of the argument. The argument is an
1300 expression. If the expression contains spaces it needs to be
1301 included in double quotes. */
1304 mi_cmd_data_evaluate_expression (char *command, char **argv, int argc)
1306 struct expression *expr;
1307 struct cleanup *old_chain;
1309 struct ui_file *stb;
1310 struct value_print_options opts;
1311 struct ui_out *uiout = current_uiout;
1313 stb = mem_fileopen ();
1314 old_chain = make_cleanup_ui_file_delete (stb);
1317 error (_("-data-evaluate-expression: "
1318 "Usage: -data-evaluate-expression expression"));
1320 expr = parse_expression (argv[0]);
1322 make_cleanup (free_current_contents, &expr);
1324 val = evaluate_expression (expr);
1326 /* Print the result of the expression evaluation. */
1327 get_user_print_options (&opts);
1329 common_val_print (val, stb, 0, &opts, current_language);
1331 ui_out_field_stream (uiout, "value", stb);
1333 do_cleanups (old_chain);
1336 /* This is the -data-read-memory command.
1338 ADDR: start address of data to be dumped.
1339 WORD-FORMAT: a char indicating format for the ``word''. See
1341 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
1342 NR_ROW: Number of rows.
1343 NR_COL: The number of colums (words per row).
1344 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
1345 ASCHAR for unprintable characters.
1347 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
1348 displayes them. Returns:
1350 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
1353 The number of bytes read is SIZE*ROW*COL. */
1356 mi_cmd_data_read_memory (char *command, char **argv, int argc)
1358 struct gdbarch *gdbarch = get_current_arch ();
1359 struct ui_out *uiout = current_uiout;
1360 struct cleanup *cleanups = make_cleanup (null_cleanup, NULL);
1362 long total_bytes, nr_cols, nr_rows;
1364 struct type *word_type;
1377 static const struct mi_opt opts[] =
1379 {"o", OFFSET_OPT, 1},
1385 int opt = mi_getopt ("-data-read-memory", argc, argv, opts,
1390 switch ((enum opt) opt)
1393 offset = atol (oarg);
1400 if (argc < 5 || argc > 6)
1401 error (_("-data-read-memory: Usage: "
1402 "ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR]."));
1404 /* Extract all the arguments. */
1406 /* Start address of the memory dump. */
1407 addr = parse_and_eval_address (argv[0]) + offset;
1408 /* The format character to use when displaying a memory word. See
1409 the ``x'' command. */
1410 word_format = argv[1][0];
1411 /* The size of the memory word. */
1412 word_size = atol (argv[2]);
1416 word_type = builtin_type (gdbarch)->builtin_int8;
1420 word_type = builtin_type (gdbarch)->builtin_int16;
1424 word_type = builtin_type (gdbarch)->builtin_int32;
1428 word_type = builtin_type (gdbarch)->builtin_int64;
1432 word_type = builtin_type (gdbarch)->builtin_int8;
1435 /* The number of rows. */
1436 nr_rows = atol (argv[3]);
1438 error (_("-data-read-memory: invalid number of rows."));
1440 /* Number of bytes per row. */
1441 nr_cols = atol (argv[4]);
1443 error (_("-data-read-memory: invalid number of columns."));
1445 /* The un-printable character when printing ascii. */
1451 /* Create a buffer and read it in. */
1452 total_bytes = word_size * nr_rows * nr_cols;
1453 mbuf = xcalloc (total_bytes, 1);
1454 make_cleanup (xfree, mbuf);
1456 /* Dispatch memory reads to the topmost target, not the flattened
1458 nr_bytes = target_read (current_target.beneath,
1459 TARGET_OBJECT_MEMORY, NULL, mbuf,
1462 error (_("Unable to read memory."));
1464 /* Output the header information. */
1465 ui_out_field_core_addr (uiout, "addr", gdbarch, addr);
1466 ui_out_field_int (uiout, "nr-bytes", nr_bytes);
1467 ui_out_field_int (uiout, "total-bytes", total_bytes);
1468 ui_out_field_core_addr (uiout, "next-row",
1469 gdbarch, addr + word_size * nr_cols);
1470 ui_out_field_core_addr (uiout, "prev-row",
1471 gdbarch, addr - word_size * nr_cols);
1472 ui_out_field_core_addr (uiout, "next-page", gdbarch, addr + total_bytes);
1473 ui_out_field_core_addr (uiout, "prev-page", gdbarch, addr - total_bytes);
1475 /* Build the result as a two dimentional table. */
1477 struct ui_file *stream;
1478 struct cleanup *cleanup_stream;
1482 stream = mem_fileopen ();
1483 cleanup_stream = make_cleanup_ui_file_delete (stream);
1485 make_cleanup_ui_out_list_begin_end (uiout, "memory");
1486 for (row = 0, row_byte = 0;
1488 row++, row_byte += nr_cols * word_size)
1492 struct cleanup *cleanup_tuple;
1493 struct cleanup *cleanup_list_data;
1494 struct value_print_options opts;
1496 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1497 ui_out_field_core_addr (uiout, "addr", gdbarch, addr + row_byte);
1498 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr +
1500 cleanup_list_data = make_cleanup_ui_out_list_begin_end (uiout, "data");
1501 get_formatted_print_options (&opts, word_format);
1502 for (col = 0, col_byte = row_byte;
1504 col++, col_byte += word_size)
1506 if (col_byte + word_size > nr_bytes)
1508 ui_out_field_string (uiout, NULL, "N/A");
1512 ui_file_rewind (stream);
1513 print_scalar_formatted (mbuf + col_byte, word_type, &opts,
1514 word_asize, stream);
1515 ui_out_field_stream (uiout, NULL, stream);
1518 do_cleanups (cleanup_list_data);
1523 ui_file_rewind (stream);
1524 for (byte = row_byte;
1525 byte < row_byte + word_size * nr_cols; byte++)
1527 if (byte >= nr_bytes)
1528 fputc_unfiltered ('X', stream);
1529 else if (mbuf[byte] < 32 || mbuf[byte] > 126)
1530 fputc_unfiltered (aschar, stream);
1532 fputc_unfiltered (mbuf[byte], stream);
1534 ui_out_field_stream (uiout, "ascii", stream);
1536 do_cleanups (cleanup_tuple);
1538 do_cleanups (cleanup_stream);
1540 do_cleanups (cleanups);
1544 mi_cmd_data_read_memory_bytes (char *command, char **argv, int argc)
1546 struct gdbarch *gdbarch = get_current_arch ();
1547 struct ui_out *uiout = current_uiout;
1548 struct cleanup *cleanups;
1551 memory_read_result_s *read_result;
1553 VEC(memory_read_result_s) *result;
1561 static const struct mi_opt opts[] =
1563 {"o", OFFSET_OPT, 1},
1569 int opt = mi_getopt ("-data-read-memory-bytes", argc, argv, opts,
1573 switch ((enum opt) opt)
1576 offset = atol (oarg);
1584 error (_("Usage: [ -o OFFSET ] ADDR LENGTH."));
1586 addr = parse_and_eval_address (argv[0]) + offset;
1587 length = atol (argv[1]);
1589 result = read_memory_robust (current_target.beneath, addr, length);
1591 cleanups = make_cleanup (free_memory_read_result_vector, result);
1593 if (VEC_length (memory_read_result_s, result) == 0)
1594 error (_("Unable to read memory."));
1596 make_cleanup_ui_out_list_begin_end (uiout, "memory");
1598 VEC_iterate (memory_read_result_s, result, ix, read_result);
1601 struct cleanup *t = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
1605 ui_out_field_core_addr (uiout, "begin", gdbarch, read_result->begin);
1606 ui_out_field_core_addr (uiout, "offset", gdbarch, read_result->begin
1608 ui_out_field_core_addr (uiout, "end", gdbarch, read_result->end);
1610 data = xmalloc ((read_result->end - read_result->begin) * 2 + 1);
1612 for (i = 0, p = data;
1613 i < (read_result->end - read_result->begin);
1616 sprintf (p, "%02x", read_result->data[i]);
1618 ui_out_field_string (uiout, "contents", data);
1622 do_cleanups (cleanups);
1625 /* Implementation of the -data-write_memory command.
1627 COLUMN_OFFSET: optional argument. Must be preceded by '-o'. The
1628 offset from the beginning of the memory grid row where the cell to
1630 ADDR: start address of the row in the memory grid where the memory
1631 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
1632 the location to write to.
1633 FORMAT: a char indicating format for the ``word''. See
1635 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
1636 VALUE: value to be written into the memory address.
1638 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1643 mi_cmd_data_write_memory (char *command, char **argv, int argc)
1645 struct gdbarch *gdbarch = get_current_arch ();
1646 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1649 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1650 enough when using a compiler other than GCC. */
1653 struct cleanup *old_chain;
1661 static const struct mi_opt opts[] =
1663 {"o", OFFSET_OPT, 1},
1669 int opt = mi_getopt ("-data-write-memory", argc, argv, opts,
1674 switch ((enum opt) opt)
1677 offset = atol (oarg);
1685 error (_("-data-write-memory: Usage: "
1686 "[-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE."));
1688 /* Extract all the arguments. */
1689 /* Start address of the memory dump. */
1690 addr = parse_and_eval_address (argv[0]);
1691 /* The size of the memory word. */
1692 word_size = atol (argv[2]);
1694 /* Calculate the real address of the write destination. */
1695 addr += (offset * word_size);
1697 /* Get the value as a number. */
1698 value = parse_and_eval_address (argv[3]);
1699 /* Get the value into an array. */
1700 buffer = xmalloc (word_size);
1701 old_chain = make_cleanup (xfree, buffer);
1702 store_signed_integer (buffer, word_size, byte_order, value);
1703 /* Write it down to memory. */
1704 write_memory_with_notification (addr, buffer, word_size);
1705 /* Free the buffer. */
1706 do_cleanups (old_chain);
1709 /* Implementation of the -data-write-memory-bytes command.
1712 DATA: string of bytes to write at that address
1713 COUNT: number of bytes to be filled (decimal integer). */
1716 mi_cmd_data_write_memory_bytes (char *command, char **argv, int argc)
1722 size_t len, i, steps, remainder;
1724 struct cleanup *back_to;
1726 if (argc != 2 && argc != 3)
1727 error (_("Usage: ADDR DATA [COUNT]."));
1729 addr = parse_and_eval_address (argv[0]);
1731 if (strlen (cdata) % 2)
1732 error (_("Hex-encoded '%s' must have an even number of characters."),
1735 len = strlen (cdata)/2;
1737 count = strtoul (argv[2], NULL, 10);
1741 databuf = xmalloc (len * sizeof (gdb_byte));
1742 back_to = make_cleanup (xfree, databuf);
1744 for (i = 0; i < len; ++i)
1747 if (sscanf (cdata + i * 2, "%02x", &x) != 1)
1748 error (_("Invalid argument"));
1749 databuf[i] = (gdb_byte) x;
1754 /* Pattern is made of less bytes than count:
1755 repeat pattern to fill memory. */
1756 data = xmalloc (count);
1757 make_cleanup (xfree, data);
1759 steps = count / len;
1760 remainder = count % len;
1761 for (j = 0; j < steps; j++)
1762 memcpy (data + j * len, databuf, len);
1765 memcpy (data + steps * len, databuf, remainder);
1769 /* Pattern is longer than or equal to count:
1770 just copy count bytes. */
1774 write_memory_with_notification (addr, data, count);
1776 do_cleanups (back_to);
1780 mi_cmd_enable_timings (char *command, char **argv, int argc)
1786 if (strcmp (argv[0], "yes") == 0)
1788 else if (strcmp (argv[0], "no") == 0)
1799 error (_("-enable-timings: Usage: %s {yes|no}"), command);
1803 mi_cmd_list_features (char *command, char **argv, int argc)
1807 struct cleanup *cleanup = NULL;
1808 struct ui_out *uiout = current_uiout;
1810 cleanup = make_cleanup_ui_out_list_begin_end (uiout, "features");
1811 ui_out_field_string (uiout, NULL, "frozen-varobjs");
1812 ui_out_field_string (uiout, NULL, "pending-breakpoints");
1813 ui_out_field_string (uiout, NULL, "thread-info");
1814 ui_out_field_string (uiout, NULL, "data-read-memory-bytes");
1815 ui_out_field_string (uiout, NULL, "breakpoint-notifications");
1816 ui_out_field_string (uiout, NULL, "ada-task-info");
1817 ui_out_field_string (uiout, NULL, "language-option");
1818 ui_out_field_string (uiout, NULL, "info-gdb-mi-command");
1819 ui_out_field_string (uiout, NULL, "undefined-command-error-code");
1820 ui_out_field_string (uiout, NULL, "exec-run-start-option");
1822 if (ext_lang_initialized_p (get_ext_lang_defn (EXT_LANG_PYTHON)))
1823 ui_out_field_string (uiout, NULL, "python");
1825 do_cleanups (cleanup);
1829 error (_("-list-features should be passed no arguments"));
1833 mi_cmd_list_target_features (char *command, char **argv, int argc)
1837 struct cleanup *cleanup = NULL;
1838 struct ui_out *uiout = current_uiout;
1840 cleanup = make_cleanup_ui_out_list_begin_end (uiout, "features");
1841 if (target_can_async_p ())
1842 ui_out_field_string (uiout, NULL, "async");
1843 if (target_can_execute_reverse)
1844 ui_out_field_string (uiout, NULL, "reverse");
1846 do_cleanups (cleanup);
1850 error (_("-list-target-features should be passed no arguments"));
1854 mi_cmd_add_inferior (char *command, char **argv, int argc)
1856 struct inferior *inf;
1859 error (_("-add-inferior should be passed no arguments"));
1861 inf = add_inferior_with_spaces ();
1863 ui_out_field_fmt (current_uiout, "inferior", "i%d", inf->num);
1866 /* Callback used to find the first inferior other than the current
1870 get_other_inferior (struct inferior *inf, void *arg)
1872 if (inf == current_inferior ())
1879 mi_cmd_remove_inferior (char *command, char **argv, int argc)
1882 struct inferior *inf;
1885 error (_("-remove-inferior should be passed a single argument"));
1887 if (sscanf (argv[0], "i%d", &id) != 1)
1888 error (_("the thread group id is syntactically invalid"));
1890 inf = find_inferior_id (id);
1892 error (_("the specified thread group does not exist"));
1895 error (_("cannot remove an active inferior"));
1897 if (inf == current_inferior ())
1899 struct thread_info *tp = 0;
1900 struct inferior *new_inferior
1901 = iterate_over_inferiors (get_other_inferior, NULL);
1903 if (new_inferior == NULL)
1904 error (_("Cannot remove last inferior"));
1906 set_current_inferior (new_inferior);
1907 if (new_inferior->pid != 0)
1908 tp = any_thread_of_process (new_inferior->pid);
1909 switch_to_thread (tp ? tp->ptid : null_ptid);
1910 set_current_program_space (new_inferior->pspace);
1913 delete_inferior_1 (inf, 1 /* silent */);
1918 /* Execute a command within a safe environment.
1919 Return <0 for error; >=0 for ok.
1921 args->action will tell mi_execute_command what action
1922 to perfrom after the given command has executed (display/suppress
1923 prompt, display error). */
1926 captured_mi_execute_command (struct ui_out *uiout, struct mi_parse *context)
1928 struct cleanup *cleanup;
1931 current_command_ts = context->cmd_start;
1933 current_token = xstrdup (context->token);
1934 cleanup = make_cleanup (free_current_contents, ¤t_token);
1936 running_result_record_printed = 0;
1938 switch (context->op)
1941 /* A MI command was read from the input stream. */
1943 /* FIXME: gdb_???? */
1944 fprintf_unfiltered (raw_stdout, " token=`%s' command=`%s' args=`%s'\n",
1945 context->token, context->command, context->args);
1947 mi_cmd_execute (context);
1949 /* Print the result if there were no errors.
1951 Remember that on the way out of executing a command, you have
1952 to directly use the mi_interp's uiout, since the command
1953 could have reset the interpreter, in which case the current
1954 uiout will most likely crash in the mi_out_* routines. */
1955 if (!running_result_record_printed)
1957 fputs_unfiltered (context->token, raw_stdout);
1958 /* There's no particularly good reason why target-connect results
1959 in not ^done. Should kill ^connected for MI3. */
1960 fputs_unfiltered (strcmp (context->command, "target-select") == 0
1961 ? "^connected" : "^done", raw_stdout);
1962 mi_out_put (uiout, raw_stdout);
1963 mi_out_rewind (uiout);
1964 mi_print_timing_maybe ();
1965 fputs_unfiltered ("\n", raw_stdout);
1968 /* The command does not want anything to be printed. In that
1969 case, the command probably should not have written anything
1970 to uiout, but in case it has written something, discard it. */
1971 mi_out_rewind (uiout);
1978 /* A CLI command was read from the input stream. */
1979 /* This "feature" will be removed as soon as we have a
1980 complete set of mi commands. */
1981 /* Echo the command on the console. */
1982 fprintf_unfiltered (gdb_stdlog, "%s\n", context->command);
1983 /* Call the "console" interpreter. */
1984 argv[0] = "console";
1985 argv[1] = context->command;
1986 mi_cmd_interpreter_exec ("-interpreter-exec", argv, 2);
1988 /* If we changed interpreters, DON'T print out anything. */
1989 if (current_interp_named_p (INTERP_MI)
1990 || current_interp_named_p (INTERP_MI1)
1991 || current_interp_named_p (INTERP_MI2)
1992 || current_interp_named_p (INTERP_MI3))
1994 if (!running_result_record_printed)
1996 fputs_unfiltered (context->token, raw_stdout);
1997 fputs_unfiltered ("^done", raw_stdout);
1998 mi_out_put (uiout, raw_stdout);
1999 mi_out_rewind (uiout);
2000 mi_print_timing_maybe ();
2001 fputs_unfiltered ("\n", raw_stdout);
2004 mi_out_rewind (uiout);
2010 do_cleanups (cleanup);
2013 /* Print a gdb exception to the MI output stream. */
2016 mi_print_exception (const char *token, struct gdb_exception exception)
2018 fputs_unfiltered (token, raw_stdout);
2019 fputs_unfiltered ("^error,msg=\"", raw_stdout);
2020 if (exception.message == NULL)
2021 fputs_unfiltered ("unknown error", raw_stdout);
2023 fputstr_unfiltered (exception.message, '"', raw_stdout);
2024 fputs_unfiltered ("\"", raw_stdout);
2026 switch (exception.error)
2028 case UNDEFINED_COMMAND_ERROR:
2029 fputs_unfiltered (",code=\"undefined-command\"", raw_stdout);
2033 fputs_unfiltered ("\n", raw_stdout);
2037 mi_execute_command (const char *cmd, int from_tty)
2040 struct mi_parse *command = NULL;
2041 volatile struct gdb_exception exception;
2043 /* This is to handle EOF (^D). We just quit gdb. */
2044 /* FIXME: we should call some API function here. */
2046 quit_force (NULL, from_tty);
2048 target_log_command (cmd);
2050 TRY_CATCH (exception, RETURN_MASK_ALL)
2052 command = mi_parse (cmd, &token);
2054 if (exception.reason < 0)
2056 mi_print_exception (token, exception);
2061 volatile struct gdb_exception result;
2062 ptid_t previous_ptid = inferior_ptid;
2064 command->token = token;
2068 command->cmd_start = (struct mi_timestamp *)
2069 xmalloc (sizeof (struct mi_timestamp));
2070 timestamp (command->cmd_start);
2073 TRY_CATCH (result, RETURN_MASK_ALL)
2075 captured_mi_execute_command (current_uiout, command);
2077 if (result.reason < 0)
2079 /* The command execution failed and error() was called
2081 mi_print_exception (command->token, result);
2082 mi_out_rewind (current_uiout);
2085 bpstat_do_actions ();
2087 if (/* The notifications are only output when the top-level
2088 interpreter (specified on the command line) is MI. */
2089 ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ()))
2090 /* Don't try report anything if there are no threads --
2091 the program is dead. */
2092 && thread_count () != 0
2093 /* -thread-select explicitly changes thread. If frontend uses that
2094 internally, we don't want to emit =thread-selected, since
2095 =thread-selected is supposed to indicate user's intentions. */
2096 && strcmp (command->command, "thread-select") != 0)
2098 struct mi_interp *mi = top_level_interpreter_data ();
2099 int report_change = 0;
2101 if (command->thread == -1)
2103 report_change = (!ptid_equal (previous_ptid, null_ptid)
2104 && !ptid_equal (inferior_ptid, previous_ptid)
2105 && !ptid_equal (inferior_ptid, null_ptid));
2107 else if (!ptid_equal (inferior_ptid, null_ptid))
2109 struct thread_info *ti = inferior_thread ();
2111 report_change = (ti->num != command->thread);
2116 struct thread_info *ti = inferior_thread ();
2118 target_terminal_ours ();
2119 fprintf_unfiltered (mi->event_channel,
2120 "thread-selected,id=\"%d\"",
2122 gdb_flush (mi->event_channel);
2126 mi_parse_free (command);
2131 mi_cmd_execute (struct mi_parse *parse)
2133 struct cleanup *cleanup;
2134 enum language saved_language;
2136 cleanup = prepare_execute_command ();
2138 if (parse->all && parse->thread_group != -1)
2139 error (_("Cannot specify --thread-group together with --all"));
2141 if (parse->all && parse->thread != -1)
2142 error (_("Cannot specify --thread together with --all"));
2144 if (parse->thread_group != -1 && parse->thread != -1)
2145 error (_("Cannot specify --thread together with --thread-group"));
2147 if (parse->frame != -1 && parse->thread == -1)
2148 error (_("Cannot specify --frame without --thread"));
2150 if (parse->thread_group != -1)
2152 struct inferior *inf = find_inferior_id (parse->thread_group);
2153 struct thread_info *tp = 0;
2156 error (_("Invalid thread group for the --thread-group option"));
2158 set_current_inferior (inf);
2159 /* This behaviour means that if --thread-group option identifies
2160 an inferior with multiple threads, then a random one will be
2161 picked. This is not a problem -- frontend should always
2162 provide --thread if it wishes to operate on a specific
2165 tp = any_live_thread_of_process (inf->pid);
2166 switch_to_thread (tp ? tp->ptid : null_ptid);
2167 set_current_program_space (inf->pspace);
2170 if (parse->thread != -1)
2172 struct thread_info *tp = find_thread_id (parse->thread);
2175 error (_("Invalid thread id: %d"), parse->thread);
2177 if (is_exited (tp->ptid))
2178 error (_("Thread id: %d has terminated"), parse->thread);
2180 switch_to_thread (tp->ptid);
2183 if (parse->frame != -1)
2185 struct frame_info *fid;
2186 int frame = parse->frame;
2188 fid = find_relative_frame (get_current_frame (), &frame);
2190 /* find_relative_frame was successful */
2193 error (_("Invalid frame id: %d"), frame);
2196 if (parse->language != language_unknown)
2198 make_cleanup_restore_current_language ();
2199 set_language (parse->language);
2202 current_context = parse;
2204 if (parse->cmd->suppress_notification != NULL)
2206 make_cleanup_restore_integer (parse->cmd->suppress_notification);
2207 *parse->cmd->suppress_notification = 1;
2210 if (parse->cmd->argv_func != NULL)
2212 parse->cmd->argv_func (parse->command, parse->argv, parse->argc);
2214 else if (parse->cmd->cli.cmd != 0)
2216 /* FIXME: DELETE THIS. */
2217 /* The operation is still implemented by a cli command. */
2218 /* Must be a synchronous one. */
2219 mi_execute_cli_command (parse->cmd->cli.cmd, parse->cmd->cli.args_p,
2224 /* FIXME: DELETE THIS. */
2225 struct ui_file *stb;
2227 stb = mem_fileopen ();
2229 fputs_unfiltered ("Undefined mi command: ", stb);
2230 fputstr_unfiltered (parse->command, '"', stb);
2231 fputs_unfiltered (" (missing implementation)", stb);
2233 make_cleanup_ui_file_delete (stb);
2236 do_cleanups (cleanup);
2239 /* FIXME: This is just a hack so we can get some extra commands going.
2240 We don't want to channel things through the CLI, but call libgdb directly.
2241 Use only for synchronous commands. */
2244 mi_execute_cli_command (const char *cmd, int args_p, const char *args)
2248 struct cleanup *old_cleanups;
2252 run = xstrprintf ("%s %s", cmd, args);
2254 run = xstrdup (cmd);
2256 /* FIXME: gdb_???? */
2257 fprintf_unfiltered (gdb_stdout, "cli=%s run=%s\n",
2259 old_cleanups = make_cleanup (xfree, run);
2260 execute_command (run, 0 /* from_tty */ );
2261 do_cleanups (old_cleanups);
2267 mi_execute_async_cli_command (char *cli_command, char **argv, int argc)
2269 struct cleanup *old_cleanups;
2272 if (target_can_async_p ())
2273 run = xstrprintf ("%s %s&", cli_command, argc ? *argv : "");
2275 run = xstrprintf ("%s %s", cli_command, argc ? *argv : "");
2276 old_cleanups = make_cleanup (xfree, run);
2278 execute_command (run, 0 /* from_tty */ );
2280 /* Do this before doing any printing. It would appear that some
2281 print code leaves garbage around in the buffer. */
2282 do_cleanups (old_cleanups);
2286 mi_load_progress (const char *section_name,
2287 unsigned long sent_so_far,
2288 unsigned long total_section,
2289 unsigned long total_sent,
2290 unsigned long grand_total)
2292 struct timeval time_now, delta, update_threshold;
2293 static struct timeval last_update;
2294 static char *previous_sect_name = NULL;
2296 struct ui_out *saved_uiout;
2297 struct ui_out *uiout;
2299 /* This function is called through deprecated_show_load_progress
2300 which means uiout may not be correct. Fix it for the duration
2301 of this function. */
2302 saved_uiout = current_uiout;
2304 if (current_interp_named_p (INTERP_MI)
2305 || current_interp_named_p (INTERP_MI2))
2306 current_uiout = mi_out_new (2);
2307 else if (current_interp_named_p (INTERP_MI1))
2308 current_uiout = mi_out_new (1);
2309 else if (current_interp_named_p (INTERP_MI3))
2310 current_uiout = mi_out_new (3);
2314 uiout = current_uiout;
2316 update_threshold.tv_sec = 0;
2317 update_threshold.tv_usec = 500000;
2318 gettimeofday (&time_now, NULL);
2320 delta.tv_usec = time_now.tv_usec - last_update.tv_usec;
2321 delta.tv_sec = time_now.tv_sec - last_update.tv_sec;
2323 if (delta.tv_usec < 0)
2326 delta.tv_usec += 1000000L;
2329 new_section = (previous_sect_name ?
2330 strcmp (previous_sect_name, section_name) : 1);
2333 struct cleanup *cleanup_tuple;
2335 xfree (previous_sect_name);
2336 previous_sect_name = xstrdup (section_name);
2339 fputs_unfiltered (current_token, raw_stdout);
2340 fputs_unfiltered ("+download", raw_stdout);
2341 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
2342 ui_out_field_string (uiout, "section", section_name);
2343 ui_out_field_int (uiout, "section-size", total_section);
2344 ui_out_field_int (uiout, "total-size", grand_total);
2345 do_cleanups (cleanup_tuple);
2346 mi_out_put (uiout, raw_stdout);
2347 fputs_unfiltered ("\n", raw_stdout);
2348 gdb_flush (raw_stdout);
2351 if (delta.tv_sec >= update_threshold.tv_sec &&
2352 delta.tv_usec >= update_threshold.tv_usec)
2354 struct cleanup *cleanup_tuple;
2356 last_update.tv_sec = time_now.tv_sec;
2357 last_update.tv_usec = time_now.tv_usec;
2359 fputs_unfiltered (current_token, raw_stdout);
2360 fputs_unfiltered ("+download", raw_stdout);
2361 cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
2362 ui_out_field_string (uiout, "section", section_name);
2363 ui_out_field_int (uiout, "section-sent", sent_so_far);
2364 ui_out_field_int (uiout, "section-size", total_section);
2365 ui_out_field_int (uiout, "total-sent", total_sent);
2366 ui_out_field_int (uiout, "total-size", grand_total);
2367 do_cleanups (cleanup_tuple);
2368 mi_out_put (uiout, raw_stdout);
2369 fputs_unfiltered ("\n", raw_stdout);
2370 gdb_flush (raw_stdout);
2374 current_uiout = saved_uiout;
2378 timestamp (struct mi_timestamp *tv)
2380 gettimeofday (&tv->wallclock, NULL);
2381 #ifdef HAVE_GETRUSAGE
2382 getrusage (RUSAGE_SELF, &rusage);
2383 tv->utime.tv_sec = rusage.ru_utime.tv_sec;
2384 tv->utime.tv_usec = rusage.ru_utime.tv_usec;
2385 tv->stime.tv_sec = rusage.ru_stime.tv_sec;
2386 tv->stime.tv_usec = rusage.ru_stime.tv_usec;
2389 long usec = get_run_time ();
2391 tv->utime.tv_sec = usec/1000000L;
2392 tv->utime.tv_usec = usec - 1000000L*tv->utime.tv_sec;
2393 tv->stime.tv_sec = 0;
2394 tv->stime.tv_usec = 0;
2400 print_diff_now (struct mi_timestamp *start)
2402 struct mi_timestamp now;
2405 print_diff (start, &now);
2409 mi_print_timing_maybe (void)
2411 /* If the command is -enable-timing then do_timings may be true
2412 whilst current_command_ts is not initialized. */
2413 if (do_timings && current_command_ts)
2414 print_diff_now (current_command_ts);
2418 timeval_diff (struct timeval start, struct timeval end)
2420 return ((end.tv_sec - start.tv_sec) * 1000000L)
2421 + (end.tv_usec - start.tv_usec);
2425 print_diff (struct mi_timestamp *start, struct mi_timestamp *end)
2429 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
2430 timeval_diff (start->wallclock, end->wallclock) / 1000000.0,
2431 timeval_diff (start->utime, end->utime) / 1000000.0,
2432 timeval_diff (start->stime, end->stime) / 1000000.0);
2436 mi_cmd_trace_define_variable (char *command, char **argv, int argc)
2438 struct expression *expr;
2439 LONGEST initval = 0;
2440 struct trace_state_variable *tsv;
2443 if (argc != 1 && argc != 2)
2444 error (_("Usage: -trace-define-variable VARIABLE [VALUE]"));
2448 error (_("Name of trace variable should start with '$'"));
2450 validate_trace_state_variable_name (name);
2452 tsv = find_trace_state_variable (name);
2454 tsv = create_trace_state_variable (name);
2457 initval = value_as_long (parse_and_eval (argv[1]));
2459 tsv->initial_value = initval;
2463 mi_cmd_trace_list_variables (char *command, char **argv, int argc)
2466 error (_("-trace-list-variables: no arguments allowed"));
2468 tvariables_info_1 ();
2472 mi_cmd_trace_find (char *command, char **argv, int argc)
2477 error (_("trace selection mode is required"));
2481 if (strcmp (mode, "none") == 0)
2483 tfind_1 (tfind_number, -1, 0, 0, 0);
2487 check_trace_running (current_trace_status ());
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);