3 Copyright (C) 2000-2017 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 "gdbthread.h"
31 #include "mi-getopt.h"
32 #include "mi-console.h"
36 #include "event-loop.h"
37 #include "event-top.h"
38 #include "gdbcore.h" /* For write_memory(). */
44 #include "mi-common.h"
49 #include "splay-tree.h"
50 #include "tracepoint.h"
54 #include "extension.h"
57 #include "common/gdb_optional.h"
60 #include "run-time-clock.h"
70 /* This is used to pass the current command timestamp down to
71 continuation routines. */
72 static struct mi_timestamp *current_command_ts;
74 static int do_timings = 0;
77 /* Few commands would like to know if options like --thread-group were
78 explicitly specified. This variable keeps the current parsed
79 command including all option, and make it possible. */
80 static struct mi_parse *current_context;
82 int running_result_record_printed = 1;
84 /* Flag indicating that the target has proceeded since the last
85 command was issued. */
88 extern void _initialize_mi_main (void);
89 static void mi_cmd_execute (struct mi_parse *parse);
91 static void mi_execute_cli_command (const char *cmd, int args_p,
93 static void mi_execute_async_cli_command (const char *cli_command,
94 char **argv, int argc);
95 static int register_changed_p (int regnum, struct regcache *,
97 static void output_register (struct frame_info *, int regnum, int format,
98 int skip_unavailable);
100 /* Controls whether the frontend wants MI in async mode. */
101 static int mi_async = 0;
103 /* The set command writes to this variable. If the inferior is
104 executing, mi_async is *not* updated. */
105 static int mi_async_1 = 0;
108 set_mi_async_command (char *args, int from_tty,
109 struct cmd_list_element *c)
111 if (have_live_inferiors ())
113 mi_async_1 = mi_async;
114 error (_("Cannot change this setting while the inferior is running."));
117 mi_async = mi_async_1;
121 show_mi_async_command (struct ui_file *file, int from_tty,
122 struct cmd_list_element *c,
125 fprintf_filtered (file,
126 _("Whether MI is in asynchronous mode is %s.\n"),
130 /* A wrapper for target_can_async_p that takes the MI setting into
136 return mi_async && target_can_async_p ();
139 /* Command implementations. FIXME: Is this libgdb? No. This is the MI
140 layer that calls libgdb. Any operation used in the below should be
143 static void timestamp (struct mi_timestamp *tv);
145 static void print_diff (struct ui_file *file, struct mi_timestamp *start,
146 struct mi_timestamp *end);
149 mi_cmd_gdb_exit (const char *command, char **argv, int argc)
151 struct mi_interp *mi = (struct mi_interp *) current_interpreter ();
153 /* We have to print everything right here because we never return. */
155 fputs_unfiltered (current_token, mi->raw_stdout);
156 fputs_unfiltered ("^exit\n", mi->raw_stdout);
157 mi_out_put (current_uiout, mi->raw_stdout);
158 gdb_flush (mi->raw_stdout);
159 /* FIXME: The function called is not yet a formal libgdb function. */
160 quit_force (NULL, FROM_TTY);
164 mi_cmd_exec_next (const char *command, char **argv, int argc)
166 /* FIXME: Should call a libgdb function, not a cli wrapper. */
167 if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
168 mi_execute_async_cli_command ("reverse-next", argv + 1, argc - 1);
170 mi_execute_async_cli_command ("next", argv, argc);
174 mi_cmd_exec_next_instruction (const char *command, char **argv, int argc)
176 /* FIXME: Should call a libgdb function, not a cli wrapper. */
177 if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
178 mi_execute_async_cli_command ("reverse-nexti", argv + 1, argc - 1);
180 mi_execute_async_cli_command ("nexti", argv, argc);
184 mi_cmd_exec_step (const char *command, char **argv, int argc)
186 /* FIXME: Should call a libgdb function, not a cli wrapper. */
187 if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
188 mi_execute_async_cli_command ("reverse-step", argv + 1, argc - 1);
190 mi_execute_async_cli_command ("step", argv, argc);
194 mi_cmd_exec_step_instruction (const char *command, char **argv, int argc)
196 /* FIXME: Should call a libgdb function, not a cli wrapper. */
197 if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
198 mi_execute_async_cli_command ("reverse-stepi", argv + 1, argc - 1);
200 mi_execute_async_cli_command ("stepi", argv, argc);
204 mi_cmd_exec_finish (const char *command, char **argv, int argc)
206 /* FIXME: Should call a libgdb function, not a cli wrapper. */
207 if (argc > 0 && strcmp(argv[0], "--reverse") == 0)
208 mi_execute_async_cli_command ("reverse-finish", argv + 1, argc - 1);
210 mi_execute_async_cli_command ("finish", argv, argc);
214 mi_cmd_exec_return (const char *command, char **argv, int argc)
216 /* This command doesn't really execute the target, it just pops the
217 specified number of frames. */
219 /* Call return_command with from_tty argument equal to 0 so as to
220 avoid being queried. */
221 return_command (*argv, 0);
223 /* Call return_command with from_tty argument equal to 0 so as to
224 avoid being queried. */
225 return_command (NULL, 0);
227 /* Because we have called return_command with from_tty = 0, we need
228 to print the frame here. */
229 print_stack_frame (get_selected_frame (NULL), 1, LOC_AND_ADDRESS, 1);
233 mi_cmd_exec_jump (const char *args, char **argv, int argc)
235 /* FIXME: Should call a libgdb function, not a cli wrapper. */
236 mi_execute_async_cli_command ("jump", argv, argc);
240 proceed_thread (struct thread_info *thread, int pid)
242 if (!is_stopped (thread->ptid))
245 if (pid != 0 && ptid_get_pid (thread->ptid) != pid)
248 switch_to_thread (thread->ptid);
249 clear_proceed_status (0);
250 proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT);
254 proceed_thread_callback (struct thread_info *thread, void *arg)
256 int pid = *(int *)arg;
258 proceed_thread (thread, pid);
263 exec_continue (char **argv, int argc)
265 prepare_execution_command (¤t_target, mi_async_p ());
269 /* In non-stop mode, 'resume' always resumes a single thread.
270 Therefore, to resume all threads of the current inferior, or
271 all threads in all inferiors, we need to iterate over
274 See comment on infcmd.c:proceed_thread_callback for rationale. */
275 if (current_context->all || current_context->thread_group != -1)
278 struct cleanup *back_to = make_cleanup_restore_current_thread ();
280 if (!current_context->all)
283 = find_inferior_id (current_context->thread_group);
287 iterate_over_threads (proceed_thread_callback, &pid);
288 do_cleanups (back_to);
297 scoped_restore save_multi = make_scoped_restore (&sched_multi);
299 if (current_context->all)
306 /* In all-stop mode, -exec-continue traditionally resumed
307 either all threads, or one thread, depending on the
308 'scheduler-locking' variable. Let's continue to do the
316 exec_reverse_continue (char **argv, int argc)
318 enum exec_direction_kind dir = execution_direction;
320 if (dir == EXEC_REVERSE)
321 error (_("Already in reverse mode."));
323 if (!target_can_execute_reverse)
324 error (_("Target %s does not support this command."), target_shortname);
326 scoped_restore save_exec_dir = make_scoped_restore (&execution_direction,
328 exec_continue (argv, argc);
332 mi_cmd_exec_continue (const char *command, char **argv, int argc)
334 if (argc > 0 && strcmp (argv[0], "--reverse") == 0)
335 exec_reverse_continue (argv + 1, argc - 1);
337 exec_continue (argv, argc);
341 interrupt_thread_callback (struct thread_info *thread, void *arg)
343 int pid = *(int *)arg;
345 if (!is_running (thread->ptid))
348 if (ptid_get_pid (thread->ptid) != pid)
351 target_stop (thread->ptid);
355 /* Interrupt the execution of the target. Note how we must play
356 around with the token variables, in order to display the current
357 token in the result of the interrupt command, and the previous
358 execution token when the target finally stops. See comments in
362 mi_cmd_exec_interrupt (const char *command, char **argv, int argc)
364 /* In all-stop mode, everything stops, so we don't need to try
365 anything specific. */
368 interrupt_target_1 (0);
372 if (current_context->all)
374 /* This will interrupt all threads in all inferiors. */
375 interrupt_target_1 (1);
377 else if (current_context->thread_group != -1)
379 struct inferior *inf = find_inferior_id (current_context->thread_group);
381 iterate_over_threads (interrupt_thread_callback, &inf->pid);
385 /* Interrupt just the current thread -- either explicitly
386 specified via --thread or whatever was current before
387 MI command was sent. */
388 interrupt_target_1 (0);
392 /* Callback for iterate_over_inferiors which starts the execution
393 of the given inferior.
395 ARG is a pointer to an integer whose value, if non-zero, indicates
396 that the program should be stopped when reaching the main subprogram
397 (similar to what the CLI "start" command does). */
400 run_one_inferior (struct inferior *inf, void *arg)
402 int start_p = *(int *) arg;
403 const char *run_cmd = start_p ? "start" : "run";
404 struct target_ops *run_target = find_run_target ();
405 int async_p = mi_async && run_target->to_can_async_p (run_target);
409 if (inf->pid != ptid_get_pid (inferior_ptid))
411 struct thread_info *tp;
413 tp = any_thread_of_process (inf->pid);
415 error (_("Inferior has no threads."));
417 switch_to_thread (tp->ptid);
422 set_current_inferior (inf);
423 switch_to_thread (null_ptid);
424 set_current_program_space (inf->pspace);
426 mi_execute_cli_command (run_cmd, async_p,
427 async_p ? "&" : NULL);
432 mi_cmd_exec_run (const char *command, char **argv, int argc)
436 /* Parse the command options. */
441 static const struct mi_opt opts[] =
443 {"-start", START_OPT, 0},
452 int opt = mi_getopt ("-exec-run", argc, argv, opts, &oind, &oarg);
456 switch ((enum opt) opt)
464 /* This command does not accept any argument. Make sure the user
465 did not provide any. */
467 error (_("Invalid argument: %s"), argv[oind]);
469 if (current_context->all)
471 struct cleanup *back_to = save_current_space_and_thread ();
473 iterate_over_inferiors (run_one_inferior, &start_p);
474 do_cleanups (back_to);
478 const char *run_cmd = start_p ? "start" : "run";
479 struct target_ops *run_target = find_run_target ();
480 int async_p = mi_async && run_target->to_can_async_p (run_target);
482 mi_execute_cli_command (run_cmd, async_p,
483 async_p ? "&" : NULL);
489 find_thread_of_process (struct thread_info *ti, void *p)
493 if (ptid_get_pid (ti->ptid) == pid && !is_exited (ti->ptid))
500 mi_cmd_target_detach (const char *command, char **argv, int argc)
502 if (argc != 0 && argc != 1)
503 error (_("Usage: -target-detach [pid | thread-group]"));
507 struct thread_info *tp;
511 /* First see if we are dealing with a thread-group id. */
514 struct inferior *inf;
515 int id = strtoul (argv[0] + 1, &end, 0);
518 error (_("Invalid syntax of thread-group id '%s'"), argv[0]);
520 inf = find_inferior_id (id);
522 error (_("Non-existent thread-group id '%d'"), id);
528 /* We must be dealing with a pid. */
529 pid = strtol (argv[0], &end, 10);
532 error (_("Invalid identifier '%s'"), argv[0]);
535 /* Pick any thread in the desired process. Current
536 target_detach detaches from the parent of inferior_ptid. */
537 tp = iterate_over_threads (find_thread_of_process, &pid);
539 error (_("Thread group is empty"));
541 switch_to_thread (tp->ptid);
544 detach_command (NULL, 0);
548 mi_cmd_target_flash_erase (const char *command, char **argv, int argc)
550 flash_erase_command (NULL, 0);
554 mi_cmd_thread_select (const char *command, char **argv, int argc)
557 char *mi_error_message;
558 ptid_t previous_ptid = inferior_ptid;
561 error (_("-thread-select: USAGE: threadnum."));
563 rc = gdb_thread_select (current_uiout, argv[0], &mi_error_message);
565 /* If thread switch did not succeed don't notify or print. */
566 if (rc == GDB_RC_FAIL)
568 make_cleanup (xfree, mi_error_message);
569 error ("%s", mi_error_message);
572 print_selected_thread_frame (current_uiout,
573 USER_SELECTED_THREAD | USER_SELECTED_FRAME);
575 /* Notify if the thread has effectively changed. */
576 if (!ptid_equal (inferior_ptid, previous_ptid))
578 observer_notify_user_selected_context_changed (USER_SELECTED_THREAD
579 | USER_SELECTED_FRAME);
584 mi_cmd_thread_list_ids (const char *command, char **argv, int argc)
587 char *mi_error_message;
590 error (_("-thread-list-ids: No arguments required."));
592 rc = gdb_list_thread_ids (current_uiout, &mi_error_message);
594 if (rc == GDB_RC_FAIL)
596 make_cleanup (xfree, mi_error_message);
597 error ("%s", mi_error_message);
602 mi_cmd_thread_info (const char *command, char **argv, int argc)
604 if (argc != 0 && argc != 1)
605 error (_("Invalid MI command"));
607 print_thread_info (current_uiout, argv[0], -1);
610 struct collect_cores_data
618 collect_cores (struct thread_info *ti, void *xdata)
620 struct collect_cores_data *data = (struct collect_cores_data *) xdata;
622 if (ptid_get_pid (ti->ptid) == data->pid)
624 int core = target_core_of_thread (ti->ptid);
627 VEC_safe_push (int, data->cores, core);
634 unique (int *b, int *e)
644 struct print_one_inferior_data
647 VEC (int) *inferiors;
651 print_one_inferior (struct inferior *inferior, void *xdata)
653 struct print_one_inferior_data *top_data
654 = (struct print_one_inferior_data *) xdata;
655 struct ui_out *uiout = current_uiout;
657 if (VEC_empty (int, top_data->inferiors)
658 || bsearch (&(inferior->pid), VEC_address (int, top_data->inferiors),
659 VEC_length (int, top_data->inferiors), sizeof (int),
660 compare_positive_ints))
662 struct collect_cores_data data;
663 ui_out_emit_tuple tuple_emitter (uiout, NULL);
665 uiout->field_fmt ("id", "i%d", inferior->num);
666 uiout->field_string ("type", "process");
667 if (inferior->has_exit_code)
668 uiout->field_string ("exit-code",
669 int_string (inferior->exit_code, 8, 0, 0, 1));
670 if (inferior->pid != 0)
671 uiout->field_int ("pid", inferior->pid);
673 if (inferior->pspace->pspace_exec_filename != NULL)
675 uiout->field_string ("executable",
676 inferior->pspace->pspace_exec_filename);
680 if (inferior->pid != 0)
682 data.pid = inferior->pid;
683 iterate_over_threads (collect_cores, &data);
686 if (!VEC_empty (int, data.cores))
689 ui_out_emit_list list_emitter (uiout, "cores");
691 qsort (VEC_address (int, data.cores),
692 VEC_length (int, data.cores), sizeof (int),
693 compare_positive_ints);
695 b = VEC_address (int, data.cores);
696 e = b + VEC_length (int, data.cores);
700 uiout->field_int (NULL, *b);
703 if (top_data->recurse)
704 print_thread_info (uiout, NULL, inferior->pid);
710 /* Output a field named 'cores' with a list as the value. The
711 elements of the list are obtained by splitting 'cores' on
715 output_cores (struct ui_out *uiout, const char *field_name, const char *xcores)
717 struct cleanup *back_to = make_cleanup_ui_out_list_begin_end (uiout,
719 char *cores = xstrdup (xcores);
722 make_cleanup (xfree, cores);
724 for (p = strtok (p, ","); p; p = strtok (NULL, ","))
725 uiout->field_string (NULL, p);
727 do_cleanups (back_to);
731 free_vector_of_ints (void *xvector)
733 VEC (int) **vector = (VEC (int) **) xvector;
735 VEC_free (int, *vector);
739 do_nothing (splay_tree_key k)
744 free_vector_of_osdata_items (splay_tree_value xvalue)
746 VEC (osdata_item_s) *value = (VEC (osdata_item_s) *) xvalue;
748 /* We don't free the items itself, it will be done separately. */
749 VEC_free (osdata_item_s, value);
753 splay_tree_int_comparator (splay_tree_key xa, splay_tree_key xb)
762 free_splay_tree (void *xt)
764 splay_tree t = (splay_tree) xt;
765 splay_tree_delete (t);
769 list_available_thread_groups (VEC (int) *ids, int recurse)
772 struct osdata_item *item;
774 struct ui_out *uiout = current_uiout;
775 struct cleanup *cleanup;
777 /* This keeps a map from integer (pid) to VEC (struct osdata_item *)*
778 The vector contains information about all threads for the given pid.
779 This is assigned an initial value to avoid "may be used uninitialized"
781 splay_tree tree = NULL;
783 /* get_osdata will throw if it cannot return data. */
784 data = get_osdata ("processes");
785 cleanup = make_cleanup_osdata_free (data);
789 struct osdata *threads = get_osdata ("threads");
791 make_cleanup_osdata_free (threads);
792 tree = splay_tree_new (splay_tree_int_comparator,
794 free_vector_of_osdata_items);
795 make_cleanup (free_splay_tree, tree);
798 VEC_iterate (osdata_item_s, threads->items,
802 const char *pid = get_osdata_column (item, "pid");
803 int pid_i = strtoul (pid, NULL, 0);
804 VEC (osdata_item_s) *vec = 0;
806 splay_tree_node n = splay_tree_lookup (tree, pid_i);
809 VEC_safe_push (osdata_item_s, vec, item);
810 splay_tree_insert (tree, pid_i, (splay_tree_value)vec);
814 vec = (VEC (osdata_item_s) *) n->value;
815 VEC_safe_push (osdata_item_s, vec, item);
816 n->value = (splay_tree_value) vec;
821 make_cleanup_ui_out_list_begin_end (uiout, "groups");
824 VEC_iterate (osdata_item_s, data->items,
828 const char *pid = get_osdata_column (item, "pid");
829 const char *cmd = get_osdata_column (item, "command");
830 const char *user = get_osdata_column (item, "user");
831 const char *cores = get_osdata_column (item, "cores");
833 int pid_i = strtoul (pid, NULL, 0);
835 /* At present, the target will return all available processes
836 and if information about specific ones was required, we filter
837 undesired processes here. */
838 if (ids && bsearch (&pid_i, VEC_address (int, ids),
839 VEC_length (int, ids),
840 sizeof (int), compare_positive_ints) == NULL)
844 ui_out_emit_tuple tuple_emitter (uiout, NULL);
846 uiout->field_fmt ("id", "%s", pid);
847 uiout->field_string ("type", "process");
849 uiout->field_string ("description", cmd);
851 uiout->field_string ("user", user);
853 output_cores (uiout, "cores", cores);
857 splay_tree_node n = splay_tree_lookup (tree, pid_i);
860 VEC (osdata_item_s) *children = (VEC (osdata_item_s) *) n->value;
861 struct osdata_item *child;
864 make_cleanup_ui_out_list_begin_end (uiout, "threads");
867 VEC_iterate (osdata_item_s, children, ix_child, child);
870 ui_out_emit_tuple tuple_emitter (uiout, NULL);
871 const char *tid = get_osdata_column (child, "tid");
872 const char *tcore = get_osdata_column (child, "core");
874 uiout->field_string ("id", tid);
876 uiout->field_string ("core", tcore);
882 do_cleanups (cleanup);
886 mi_cmd_list_thread_groups (const char *command, char **argv, int argc)
888 struct ui_out *uiout = current_uiout;
889 struct cleanup *back_to;
896 AVAILABLE_OPT, RECURSE_OPT
898 static const struct mi_opt opts[] =
900 {"-available", AVAILABLE_OPT, 0},
901 {"-recurse", RECURSE_OPT, 1},
910 int opt = mi_getopt ("-list-thread-groups", argc, argv, opts,
915 switch ((enum opt) opt)
921 if (strcmp (oarg, "0") == 0)
923 else if (strcmp (oarg, "1") == 0)
926 error (_("only '0' and '1' are valid values "
927 "for the '--recurse' option"));
932 for (; oind < argc; ++oind)
937 if (*(argv[oind]) != 'i')
938 error (_("invalid syntax of group id '%s'"), argv[oind]);
940 inf = strtoul (argv[oind] + 1, &end, 0);
943 error (_("invalid syntax of group id '%s'"), argv[oind]);
944 VEC_safe_push (int, ids, inf);
946 if (VEC_length (int, ids) > 1)
947 qsort (VEC_address (int, ids),
948 VEC_length (int, ids),
949 sizeof (int), compare_positive_ints);
951 back_to = make_cleanup (free_vector_of_ints, &ids);
955 list_available_thread_groups (ids, recurse);
957 else if (VEC_length (int, ids) == 1)
959 /* Local thread groups, single id. */
960 int id = *VEC_address (int, ids);
961 struct inferior *inf = find_inferior_id (id);
964 error (_("Non-existent thread group id '%d'"), id);
966 print_thread_info (uiout, NULL, inf->pid);
970 struct print_one_inferior_data data;
972 data.recurse = recurse;
973 data.inferiors = ids;
975 /* Local thread groups. Either no explicit ids -- and we
976 print everything, or several explicit ids. In both cases,
977 we print more than one group, and have to use 'groups'
978 as the top-level element. */
979 make_cleanup_ui_out_list_begin_end (uiout, "groups");
980 update_thread_list ();
981 iterate_over_inferiors (print_one_inferior, &data);
984 do_cleanups (back_to);
988 mi_cmd_data_list_register_names (const char *command, char **argv, int argc)
990 struct gdbarch *gdbarch;
991 struct ui_out *uiout = current_uiout;
995 /* Note that the test for a valid register must include checking the
996 gdbarch_register_name because gdbarch_num_regs may be allocated
997 for the union of the register sets within a family of related
998 processors. In this case, some entries of gdbarch_register_name
999 will change depending upon the particular processor being
1002 gdbarch = get_current_arch ();
1003 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
1005 ui_out_emit_list list_emitter (uiout, "register-names");
1007 if (argc == 0) /* No args, just do all the regs. */
1013 if (gdbarch_register_name (gdbarch, regnum) == NULL
1014 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
1015 uiout->field_string (NULL, "");
1017 uiout->field_string (NULL, gdbarch_register_name (gdbarch, regnum));
1021 /* Else, list of register #s, just do listed regs. */
1022 for (i = 0; i < argc; i++)
1024 regnum = atoi (argv[i]);
1025 if (regnum < 0 || regnum >= numregs)
1026 error (_("bad register number"));
1028 if (gdbarch_register_name (gdbarch, regnum) == NULL
1029 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
1030 uiout->field_string (NULL, "");
1032 uiout->field_string (NULL, gdbarch_register_name (gdbarch, regnum));
1037 mi_cmd_data_list_changed_registers (const char *command, char **argv, int argc)
1039 static struct regcache *this_regs = NULL;
1040 struct ui_out *uiout = current_uiout;
1041 struct regcache *prev_regs;
1042 struct gdbarch *gdbarch;
1043 int regnum, numregs, changed;
1045 struct cleanup *cleanup;
1047 /* The last time we visited this function, the current frame's
1048 register contents were saved in THIS_REGS. Move THIS_REGS over
1049 to PREV_REGS, and refresh THIS_REGS with the now-current register
1052 prev_regs = this_regs;
1053 this_regs = frame_save_as_regcache (get_selected_frame (NULL));
1054 cleanup = make_cleanup_regcache_xfree (prev_regs);
1056 /* Note that the test for a valid register must include checking the
1057 gdbarch_register_name because gdbarch_num_regs may be allocated
1058 for the union of the register sets within a family of related
1059 processors. In this case, some entries of gdbarch_register_name
1060 will change depending upon the particular processor being
1063 gdbarch = get_regcache_arch (this_regs);
1064 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
1066 make_cleanup_ui_out_list_begin_end (uiout, "changed-registers");
1070 /* No args, just do all the regs. */
1075 if (gdbarch_register_name (gdbarch, regnum) == NULL
1076 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
1078 changed = register_changed_p (regnum, prev_regs, this_regs);
1080 error (_("-data-list-changed-registers: "
1081 "Unable to read register contents."));
1083 uiout->field_int (NULL, regnum);
1087 /* Else, list of register #s, just do listed regs. */
1088 for (i = 0; i < argc; i++)
1090 regnum = atoi (argv[i]);
1094 && gdbarch_register_name (gdbarch, regnum) != NULL
1095 && *gdbarch_register_name (gdbarch, regnum) != '\000')
1097 changed = register_changed_p (regnum, prev_regs, this_regs);
1099 error (_("-data-list-changed-registers: "
1100 "Unable to read register contents."));
1102 uiout->field_int (NULL, regnum);
1105 error (_("bad register number"));
1107 do_cleanups (cleanup);
1111 register_changed_p (int regnum, struct regcache *prev_regs,
1112 struct regcache *this_regs)
1114 struct gdbarch *gdbarch = get_regcache_arch (this_regs);
1115 gdb_byte prev_buffer[MAX_REGISTER_SIZE];
1116 gdb_byte this_buffer[MAX_REGISTER_SIZE];
1117 enum register_status prev_status;
1118 enum register_status this_status;
1120 /* First time through or after gdbarch change consider all registers
1122 if (!prev_regs || get_regcache_arch (prev_regs) != gdbarch)
1125 /* Get register contents and compare. */
1126 prev_status = regcache_cooked_read (prev_regs, regnum, prev_buffer);
1127 this_status = regcache_cooked_read (this_regs, regnum, this_buffer);
1129 if (this_status != prev_status)
1131 else if (this_status == REG_VALID)
1132 return memcmp (prev_buffer, this_buffer,
1133 register_size (gdbarch, regnum)) != 0;
1138 /* Return a list of register number and value pairs. The valid
1139 arguments expected are: a letter indicating the format in which to
1140 display the registers contents. This can be one of: x
1141 (hexadecimal), d (decimal), N (natural), t (binary), o (octal), r
1142 (raw). After the format argument there can be a sequence of
1143 numbers, indicating which registers to fetch the content of. If
1144 the format is the only argument, a list of all the registers with
1145 their values is returned. */
1148 mi_cmd_data_list_register_values (const char *command, char **argv, int argc)
1150 struct ui_out *uiout = current_uiout;
1151 struct frame_info *frame;
1152 struct gdbarch *gdbarch;
1153 int regnum, numregs, format;
1155 int skip_unavailable = 0;
1161 static const struct mi_opt opts[] =
1163 {"-skip-unavailable", SKIP_UNAVAILABLE, 0},
1167 /* Note that the test for a valid register must include checking the
1168 gdbarch_register_name because gdbarch_num_regs may be allocated
1169 for the union of the register sets within a family of related
1170 processors. In this case, some entries of gdbarch_register_name
1171 will change depending upon the particular processor being
1177 int opt = mi_getopt ("-data-list-register-values", argc, argv,
1178 opts, &oind, &oarg);
1182 switch ((enum opt) opt)
1184 case SKIP_UNAVAILABLE:
1185 skip_unavailable = 1;
1190 if (argc - oind < 1)
1191 error (_("-data-list-register-values: Usage: "
1192 "-data-list-register-values [--skip-unavailable] <format>"
1193 " [<regnum1>...<regnumN>]"));
1195 format = (int) argv[oind][0];
1197 frame = get_selected_frame (NULL);
1198 gdbarch = get_frame_arch (frame);
1199 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
1201 ui_out_emit_list list_emitter (uiout, "register-values");
1203 if (argc - oind == 1)
1205 /* No args, beside the format: do all the regs. */
1210 if (gdbarch_register_name (gdbarch, regnum) == NULL
1211 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
1214 output_register (frame, regnum, format, skip_unavailable);
1218 /* Else, list of register #s, just do listed regs. */
1219 for (i = 1 + oind; i < argc; i++)
1221 regnum = atoi (argv[i]);
1225 && gdbarch_register_name (gdbarch, regnum) != NULL
1226 && *gdbarch_register_name (gdbarch, regnum) != '\000')
1227 output_register (frame, regnum, format, skip_unavailable);
1229 error (_("bad register number"));
1233 /* Output one register REGNUM's contents in the desired FORMAT. If
1234 SKIP_UNAVAILABLE is true, skip the register if it is
1238 output_register (struct frame_info *frame, int regnum, int format,
1239 int skip_unavailable)
1241 struct ui_out *uiout = current_uiout;
1242 struct value *val = value_of_register (regnum, frame);
1243 struct value_print_options opts;
1245 if (skip_unavailable && !value_entirely_available (val))
1248 ui_out_emit_tuple tuple_emitter (uiout, NULL);
1249 uiout->field_int ("number", regnum);
1259 get_formatted_print_options (&opts, format);
1261 val_print (value_type (val),
1262 value_embedded_offset (val), 0,
1263 &stb, 0, val, &opts, current_language);
1264 uiout->field_stream ("value", stb);
1267 /* Write given values into registers. The registers and values are
1268 given as pairs. The corresponding MI command is
1269 -data-write-register-values <format>
1270 [<regnum1> <value1>...<regnumN> <valueN>] */
1272 mi_cmd_data_write_register_values (const char *command, char **argv, int argc)
1274 struct regcache *regcache;
1275 struct gdbarch *gdbarch;
1278 /* Note that the test for a valid register must include checking the
1279 gdbarch_register_name because gdbarch_num_regs may be allocated
1280 for the union of the register sets within a family of related
1281 processors. In this case, some entries of gdbarch_register_name
1282 will change depending upon the particular processor being
1285 regcache = get_current_regcache ();
1286 gdbarch = get_regcache_arch (regcache);
1287 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
1290 error (_("-data-write-register-values: Usage: -data-write-register-"
1291 "values <format> [<regnum1> <value1>...<regnumN> <valueN>]"));
1293 if (!target_has_registers)
1294 error (_("-data-write-register-values: No registers."));
1297 error (_("-data-write-register-values: No regs and values specified."));
1300 error (_("-data-write-register-values: "
1301 "Regs and vals are not in pairs."));
1303 for (i = 1; i < argc; i = i + 2)
1305 int regnum = atoi (argv[i]);
1307 if (regnum >= 0 && regnum < numregs
1308 && gdbarch_register_name (gdbarch, regnum)
1309 && *gdbarch_register_name (gdbarch, regnum))
1313 /* Get the value as a number. */
1314 value = parse_and_eval_address (argv[i + 1]);
1316 /* Write it down. */
1317 regcache_cooked_write_signed (regcache, regnum, value);
1320 error (_("bad register number"));
1324 /* Evaluate the value of the argument. The argument is an
1325 expression. If the expression contains spaces it needs to be
1326 included in double quotes. */
1329 mi_cmd_data_evaluate_expression (const char *command, char **argv, int argc)
1332 struct value_print_options opts;
1333 struct ui_out *uiout = current_uiout;
1336 error (_("-data-evaluate-expression: "
1337 "Usage: -data-evaluate-expression expression"));
1339 expression_up expr = parse_expression (argv[0]);
1341 val = evaluate_expression (expr.get ());
1345 /* Print the result of the expression evaluation. */
1346 get_user_print_options (&opts);
1348 common_val_print (val, &stb, 0, &opts, current_language);
1350 uiout->field_stream ("value", stb);
1353 /* This is the -data-read-memory command.
1355 ADDR: start address of data to be dumped.
1356 WORD-FORMAT: a char indicating format for the ``word''. See
1358 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
1359 NR_ROW: Number of rows.
1360 NR_COL: The number of colums (words per row).
1361 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
1362 ASCHAR for unprintable characters.
1364 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
1365 displayes them. Returns:
1367 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
1370 The number of bytes read is SIZE*ROW*COL. */
1373 mi_cmd_data_read_memory (const char *command, char **argv, int argc)
1375 struct gdbarch *gdbarch = get_current_arch ();
1376 struct ui_out *uiout = current_uiout;
1378 long total_bytes, nr_cols, nr_rows;
1380 struct type *word_type;
1392 static const struct mi_opt opts[] =
1394 {"o", OFFSET_OPT, 1},
1400 int opt = mi_getopt ("-data-read-memory", argc, argv, opts,
1405 switch ((enum opt) opt)
1408 offset = atol (oarg);
1415 if (argc < 5 || argc > 6)
1416 error (_("-data-read-memory: Usage: "
1417 "ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR]."));
1419 /* Extract all the arguments. */
1421 /* Start address of the memory dump. */
1422 addr = parse_and_eval_address (argv[0]) + offset;
1423 /* The format character to use when displaying a memory word. See
1424 the ``x'' command. */
1425 word_format = argv[1][0];
1426 /* The size of the memory word. */
1427 word_size = atol (argv[2]);
1431 word_type = builtin_type (gdbarch)->builtin_int8;
1435 word_type = builtin_type (gdbarch)->builtin_int16;
1439 word_type = builtin_type (gdbarch)->builtin_int32;
1443 word_type = builtin_type (gdbarch)->builtin_int64;
1447 word_type = builtin_type (gdbarch)->builtin_int8;
1450 /* The number of rows. */
1451 nr_rows = atol (argv[3]);
1453 error (_("-data-read-memory: invalid number of rows."));
1455 /* Number of bytes per row. */
1456 nr_cols = atol (argv[4]);
1458 error (_("-data-read-memory: invalid number of columns."));
1460 /* The un-printable character when printing ascii. */
1466 /* Create a buffer and read it in. */
1467 total_bytes = word_size * nr_rows * nr_cols;
1469 std::unique_ptr<gdb_byte[]> mbuf (new gdb_byte[total_bytes]);
1471 /* Dispatch memory reads to the topmost target, not the flattened
1473 nr_bytes = target_read (current_target.beneath,
1474 TARGET_OBJECT_MEMORY, NULL, mbuf.get (),
1477 error (_("Unable to read memory."));
1479 /* Output the header information. */
1480 uiout->field_core_addr ("addr", gdbarch, addr);
1481 uiout->field_int ("nr-bytes", nr_bytes);
1482 uiout->field_int ("total-bytes", total_bytes);
1483 uiout->field_core_addr ("next-row", gdbarch, addr + word_size * nr_cols);
1484 uiout->field_core_addr ("prev-row", gdbarch, addr - word_size * nr_cols);
1485 uiout->field_core_addr ("next-page", gdbarch, addr + total_bytes);
1486 uiout->field_core_addr ("prev-page", gdbarch, addr - total_bytes);
1488 /* Build the result as a two dimentional table. */
1492 struct cleanup *cleanup_list;
1496 cleanup_list = make_cleanup_ui_out_list_begin_end (uiout, "memory");
1497 for (row = 0, row_byte = 0;
1499 row++, row_byte += nr_cols * word_size)
1503 struct cleanup *cleanup_list_data;
1504 struct value_print_options opts;
1506 ui_out_emit_tuple tuple_emitter (uiout, NULL);
1507 uiout->field_core_addr ("addr", gdbarch, addr + row_byte);
1508 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr +
1510 cleanup_list_data = make_cleanup_ui_out_list_begin_end (uiout, "data");
1511 get_formatted_print_options (&opts, word_format);
1512 for (col = 0, col_byte = row_byte;
1514 col++, col_byte += word_size)
1516 if (col_byte + word_size > nr_bytes)
1518 uiout->field_string (NULL, "N/A");
1523 print_scalar_formatted (&mbuf[col_byte], word_type, &opts,
1524 word_asize, &stream);
1525 uiout->field_stream (NULL, stream);
1528 do_cleanups (cleanup_list_data);
1534 for (byte = row_byte;
1535 byte < row_byte + word_size * nr_cols; byte++)
1537 if (byte >= nr_bytes)
1539 else if (mbuf[byte] < 32 || mbuf[byte] > 126)
1540 stream.putc (aschar);
1542 stream.putc (mbuf[byte]);
1544 uiout->field_stream ("ascii", stream);
1547 do_cleanups (cleanup_list);
1552 mi_cmd_data_read_memory_bytes (const char *command, char **argv, int argc)
1554 struct gdbarch *gdbarch = get_current_arch ();
1555 struct ui_out *uiout = current_uiout;
1556 struct cleanup *cleanups;
1559 memory_read_result_s *read_result;
1561 VEC(memory_read_result_s) *result;
1563 int unit_size = gdbarch_addressable_memory_unit_size (gdbarch);
1570 static const struct mi_opt opts[] =
1572 {"o", OFFSET_OPT, 1},
1578 int opt = mi_getopt ("-data-read-memory-bytes", argc, argv, opts,
1582 switch ((enum opt) opt)
1585 offset = atol (oarg);
1593 error (_("Usage: [ -o OFFSET ] ADDR LENGTH."));
1595 addr = parse_and_eval_address (argv[0]) + offset;
1596 length = atol (argv[1]);
1598 result = read_memory_robust (current_target.beneath, addr, length);
1600 cleanups = make_cleanup (free_memory_read_result_vector, &result);
1602 if (VEC_length (memory_read_result_s, result) == 0)
1603 error (_("Unable to read memory."));
1605 make_cleanup_ui_out_list_begin_end (uiout, "memory");
1607 VEC_iterate (memory_read_result_s, result, ix, read_result);
1610 ui_out_emit_tuple tuple_emitter (uiout, NULL);
1615 uiout->field_core_addr ("begin", gdbarch, read_result->begin);
1616 uiout->field_core_addr ("offset", gdbarch, read_result->begin - addr);
1617 uiout->field_core_addr ("end", gdbarch, read_result->end);
1619 alloc_len = (read_result->end - read_result->begin) * 2 * unit_size + 1;
1620 data = (char *) xmalloc (alloc_len);
1622 for (i = 0, p = data;
1623 i < ((read_result->end - read_result->begin) * unit_size);
1626 sprintf (p, "%02x", read_result->data[i]);
1628 uiout->field_string ("contents", data);
1631 do_cleanups (cleanups);
1634 /* Implementation of the -data-write_memory command.
1636 COLUMN_OFFSET: optional argument. Must be preceded by '-o'. The
1637 offset from the beginning of the memory grid row where the cell to
1639 ADDR: start address of the row in the memory grid where the memory
1640 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
1641 the location to write to.
1642 FORMAT: a char indicating format for the ``word''. See
1644 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
1645 VALUE: value to be written into the memory address.
1647 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1652 mi_cmd_data_write_memory (const char *command, char **argv, int argc)
1654 struct gdbarch *gdbarch = get_current_arch ();
1655 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1658 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1659 enough when using a compiler other than GCC. */
1662 struct cleanup *old_chain;
1670 static const struct mi_opt opts[] =
1672 {"o", OFFSET_OPT, 1},
1678 int opt = mi_getopt ("-data-write-memory", argc, argv, opts,
1683 switch ((enum opt) opt)
1686 offset = atol (oarg);
1694 error (_("-data-write-memory: Usage: "
1695 "[-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE."));
1697 /* Extract all the arguments. */
1698 /* Start address of the memory dump. */
1699 addr = parse_and_eval_address (argv[0]);
1700 /* The size of the memory word. */
1701 word_size = atol (argv[2]);
1703 /* Calculate the real address of the write destination. */
1704 addr += (offset * word_size);
1706 /* Get the value as a number. */
1707 value = parse_and_eval_address (argv[3]);
1708 /* Get the value into an array. */
1709 buffer = (gdb_byte *) xmalloc (word_size);
1710 old_chain = make_cleanup (xfree, buffer);
1711 store_signed_integer (buffer, word_size, byte_order, value);
1712 /* Write it down to memory. */
1713 write_memory_with_notification (addr, buffer, word_size);
1714 /* Free the buffer. */
1715 do_cleanups (old_chain);
1718 /* Implementation of the -data-write-memory-bytes command.
1721 DATA: string of bytes to write at that address
1722 COUNT: number of bytes to be filled (decimal integer). */
1725 mi_cmd_data_write_memory_bytes (const char *command, char **argv, int argc)
1731 size_t len_hex, len_bytes, len_units, i, steps, remaining_units;
1732 long int count_units;
1733 struct cleanup *back_to;
1736 if (argc != 2 && argc != 3)
1737 error (_("Usage: ADDR DATA [COUNT]."));
1739 addr = parse_and_eval_address (argv[0]);
1741 len_hex = strlen (cdata);
1742 unit_size = gdbarch_addressable_memory_unit_size (get_current_arch ());
1744 if (len_hex % (unit_size * 2) != 0)
1745 error (_("Hex-encoded '%s' must represent an integral number of "
1746 "addressable memory units."),
1749 len_bytes = len_hex / 2;
1750 len_units = len_bytes / unit_size;
1753 count_units = strtoul (argv[2], NULL, 10);
1755 count_units = len_units;
1757 databuf = XNEWVEC (gdb_byte, len_bytes);
1758 back_to = make_cleanup (xfree, databuf);
1760 for (i = 0; i < len_bytes; ++i)
1763 if (sscanf (cdata + i * 2, "%02x", &x) != 1)
1764 error (_("Invalid argument"));
1765 databuf[i] = (gdb_byte) x;
1768 if (len_units < count_units)
1770 /* Pattern is made of less units than count:
1771 repeat pattern to fill memory. */
1772 data = (gdb_byte *) xmalloc (count_units * unit_size);
1773 make_cleanup (xfree, data);
1775 /* Number of times the pattern is entirely repeated. */
1776 steps = count_units / len_units;
1777 /* Number of remaining addressable memory units. */
1778 remaining_units = count_units % len_units;
1779 for (i = 0; i < steps; i++)
1780 memcpy (data + i * len_bytes, databuf, len_bytes);
1782 if (remaining_units > 0)
1783 memcpy (data + steps * len_bytes, databuf,
1784 remaining_units * unit_size);
1788 /* Pattern is longer than or equal to count:
1789 just copy count addressable memory units. */
1793 write_memory_with_notification (addr, data, count_units);
1795 do_cleanups (back_to);
1799 mi_cmd_enable_timings (const char *command, char **argv, int argc)
1805 if (strcmp (argv[0], "yes") == 0)
1807 else if (strcmp (argv[0], "no") == 0)
1818 error (_("-enable-timings: Usage: %s {yes|no}"), command);
1822 mi_cmd_list_features (const char *command, char **argv, int argc)
1826 struct ui_out *uiout = current_uiout;
1828 ui_out_emit_list list_emitter (uiout, "features");
1829 uiout->field_string (NULL, "frozen-varobjs");
1830 uiout->field_string (NULL, "pending-breakpoints");
1831 uiout->field_string (NULL, "thread-info");
1832 uiout->field_string (NULL, "data-read-memory-bytes");
1833 uiout->field_string (NULL, "breakpoint-notifications");
1834 uiout->field_string (NULL, "ada-task-info");
1835 uiout->field_string (NULL, "language-option");
1836 uiout->field_string (NULL, "info-gdb-mi-command");
1837 uiout->field_string (NULL, "undefined-command-error-code");
1838 uiout->field_string (NULL, "exec-run-start-option");
1840 if (ext_lang_initialized_p (get_ext_lang_defn (EXT_LANG_PYTHON)))
1841 uiout->field_string (NULL, "python");
1846 error (_("-list-features should be passed no arguments"));
1850 mi_cmd_list_target_features (const char *command, char **argv, int argc)
1854 struct ui_out *uiout = current_uiout;
1856 ui_out_emit_list list_emitter (uiout, "features");
1858 uiout->field_string (NULL, "async");
1859 if (target_can_execute_reverse)
1860 uiout->field_string (NULL, "reverse");
1864 error (_("-list-target-features should be passed no arguments"));
1868 mi_cmd_add_inferior (const char *command, char **argv, int argc)
1870 struct inferior *inf;
1873 error (_("-add-inferior should be passed no arguments"));
1875 inf = add_inferior_with_spaces ();
1877 current_uiout->field_fmt ("inferior", "i%d", inf->num);
1880 /* Callback used to find the first inferior other than the current
1884 get_other_inferior (struct inferior *inf, void *arg)
1886 if (inf == current_inferior ())
1893 mi_cmd_remove_inferior (const char *command, char **argv, int argc)
1896 struct inferior *inf;
1899 error (_("-remove-inferior should be passed a single argument"));
1901 if (sscanf (argv[0], "i%d", &id) != 1)
1902 error (_("the thread group id is syntactically invalid"));
1904 inf = find_inferior_id (id);
1906 error (_("the specified thread group does not exist"));
1909 error (_("cannot remove an active inferior"));
1911 if (inf == current_inferior ())
1913 struct thread_info *tp = 0;
1914 struct inferior *new_inferior
1915 = iterate_over_inferiors (get_other_inferior, NULL);
1917 if (new_inferior == NULL)
1918 error (_("Cannot remove last inferior"));
1920 set_current_inferior (new_inferior);
1921 if (new_inferior->pid != 0)
1922 tp = any_thread_of_process (new_inferior->pid);
1923 switch_to_thread (tp ? tp->ptid : null_ptid);
1924 set_current_program_space (new_inferior->pspace);
1927 delete_inferior (inf);
1932 /* Execute a command within a safe environment.
1933 Return <0 for error; >=0 for ok.
1935 args->action will tell mi_execute_command what action
1936 to perfrom after the given command has executed (display/suppress
1937 prompt, display error). */
1940 captured_mi_execute_command (struct ui_out *uiout, struct mi_parse *context)
1942 struct mi_interp *mi = (struct mi_interp *) command_interp ();
1943 struct cleanup *cleanup;
1946 current_command_ts = context->cmd_start;
1948 current_token = xstrdup (context->token);
1949 cleanup = make_cleanup (free_current_contents, ¤t_token);
1951 running_result_record_printed = 0;
1953 switch (context->op)
1956 /* A MI command was read from the input stream. */
1958 /* FIXME: gdb_???? */
1959 fprintf_unfiltered (mi->raw_stdout,
1960 " token=`%s' command=`%s' args=`%s'\n",
1961 context->token, context->command, context->args);
1963 mi_cmd_execute (context);
1965 /* Print the result if there were no errors.
1967 Remember that on the way out of executing a command, you have
1968 to directly use the mi_interp's uiout, since the command
1969 could have reset the interpreter, in which case the current
1970 uiout will most likely crash in the mi_out_* routines. */
1971 if (!running_result_record_printed)
1973 fputs_unfiltered (context->token, mi->raw_stdout);
1974 /* There's no particularly good reason why target-connect results
1975 in not ^done. Should kill ^connected for MI3. */
1976 fputs_unfiltered (strcmp (context->command, "target-select") == 0
1977 ? "^connected" : "^done", mi->raw_stdout);
1978 mi_out_put (uiout, mi->raw_stdout);
1979 mi_out_rewind (uiout);
1980 mi_print_timing_maybe (mi->raw_stdout);
1981 fputs_unfiltered ("\n", mi->raw_stdout);
1984 /* The command does not want anything to be printed. In that
1985 case, the command probably should not have written anything
1986 to uiout, but in case it has written something, discard it. */
1987 mi_out_rewind (uiout);
1994 /* A CLI command was read from the input stream. */
1995 /* This "feature" will be removed as soon as we have a
1996 complete set of mi commands. */
1997 /* Echo the command on the console. */
1998 fprintf_unfiltered (gdb_stdlog, "%s\n", context->command);
1999 /* Call the "console" interpreter. */
2000 argv[0] = (char *) INTERP_CONSOLE;
2001 argv[1] = context->command;
2002 mi_cmd_interpreter_exec ("-interpreter-exec", argv, 2);
2004 /* If we changed interpreters, DON'T print out anything. */
2005 if (current_interp_named_p (INTERP_MI)
2006 || current_interp_named_p (INTERP_MI1)
2007 || current_interp_named_p (INTERP_MI2)
2008 || current_interp_named_p (INTERP_MI3))
2010 if (!running_result_record_printed)
2012 fputs_unfiltered (context->token, mi->raw_stdout);
2013 fputs_unfiltered ("^done", mi->raw_stdout);
2014 mi_out_put (uiout, mi->raw_stdout);
2015 mi_out_rewind (uiout);
2016 mi_print_timing_maybe (mi->raw_stdout);
2017 fputs_unfiltered ("\n", mi->raw_stdout);
2020 mi_out_rewind (uiout);
2026 do_cleanups (cleanup);
2029 /* Print a gdb exception to the MI output stream. */
2032 mi_print_exception (const char *token, struct gdb_exception exception)
2034 struct mi_interp *mi = (struct mi_interp *) current_interpreter ();
2036 fputs_unfiltered (token, mi->raw_stdout);
2037 fputs_unfiltered ("^error,msg=\"", mi->raw_stdout);
2038 if (exception.message == NULL)
2039 fputs_unfiltered ("unknown error", mi->raw_stdout);
2041 fputstr_unfiltered (exception.message, '"', mi->raw_stdout);
2042 fputs_unfiltered ("\"", mi->raw_stdout);
2044 switch (exception.error)
2046 case UNDEFINED_COMMAND_ERROR:
2047 fputs_unfiltered (",code=\"undefined-command\"", mi->raw_stdout);
2051 fputs_unfiltered ("\n", mi->raw_stdout);
2054 /* Determine whether the parsed command already notifies the
2055 user_selected_context_changed observer. */
2058 command_notifies_uscc_observer (struct mi_parse *command)
2060 if (command->op == CLI_COMMAND)
2062 /* CLI commands "thread" and "inferior" already send it. */
2063 return (strncmp (command->command, "thread ", 7) == 0
2064 || strncmp (command->command, "inferior ", 9) == 0);
2066 else /* MI_COMMAND */
2068 if (strcmp (command->command, "interpreter-exec") == 0
2069 && command->argc > 1)
2071 /* "thread" and "inferior" again, but through -interpreter-exec. */
2072 return (strncmp (command->argv[1], "thread ", 7) == 0
2073 || strncmp (command->argv[1], "inferior ", 9) == 0);
2077 /* -thread-select already sends it. */
2078 return strcmp (command->command, "thread-select") == 0;
2083 mi_execute_command (const char *cmd, int from_tty)
2086 std::unique_ptr<struct mi_parse> command;
2088 /* This is to handle EOF (^D). We just quit gdb. */
2089 /* FIXME: we should call some API function here. */
2091 quit_force (NULL, from_tty);
2093 target_log_command (cmd);
2097 command = mi_parse (cmd, &token);
2099 CATCH (exception, RETURN_MASK_ALL)
2101 mi_print_exception (token, exception);
2106 if (command != NULL)
2108 ptid_t previous_ptid = inferior_ptid;
2110 gdb::optional<scoped_restore_tmpl<int>> restore_suppress;
2112 if (command->cmd != NULL && command->cmd->suppress_notification != NULL)
2113 restore_suppress.emplace (command->cmd->suppress_notification, 1);
2115 command->token = token;
2119 command->cmd_start = new mi_timestamp ();
2120 timestamp (command->cmd_start);
2125 captured_mi_execute_command (current_uiout, command.get ());
2127 CATCH (result, RETURN_MASK_ALL)
2129 /* Like in start_event_loop, enable input and force display
2130 of the prompt. Otherwise, any command that calls
2131 async_disable_stdin, and then throws, will leave input
2133 async_enable_stdin ();
2134 current_ui->prompt_state = PROMPT_NEEDED;
2136 /* The command execution failed and error() was called
2138 mi_print_exception (command->token, result);
2139 mi_out_rewind (current_uiout);
2143 bpstat_do_actions ();
2145 if (/* The notifications are only output when the top-level
2146 interpreter (specified on the command line) is MI. */
2147 interp_ui_out (top_level_interpreter ())->is_mi_like_p ()
2148 /* Don't try report anything if there are no threads --
2149 the program is dead. */
2150 && thread_count () != 0
2151 /* If the command already reports the thread change, no need to do it
2153 && !command_notifies_uscc_observer (command.get ()))
2155 struct mi_interp *mi = (struct mi_interp *) top_level_interpreter ();
2156 int report_change = 0;
2158 if (command->thread == -1)
2160 report_change = (!ptid_equal (previous_ptid, null_ptid)
2161 && !ptid_equal (inferior_ptid, previous_ptid)
2162 && !ptid_equal (inferior_ptid, null_ptid));
2164 else if (!ptid_equal (inferior_ptid, null_ptid))
2166 struct thread_info *ti = inferior_thread ();
2168 report_change = (ti->global_num != command->thread);
2173 observer_notify_user_selected_context_changed
2174 (USER_SELECTED_THREAD | USER_SELECTED_FRAME);
2181 mi_cmd_execute (struct mi_parse *parse)
2183 struct cleanup *cleanup;
2185 cleanup = prepare_execute_command ();
2187 if (parse->all && parse->thread_group != -1)
2188 error (_("Cannot specify --thread-group together with --all"));
2190 if (parse->all && parse->thread != -1)
2191 error (_("Cannot specify --thread together with --all"));
2193 if (parse->thread_group != -1 && parse->thread != -1)
2194 error (_("Cannot specify --thread together with --thread-group"));
2196 if (parse->frame != -1 && parse->thread == -1)
2197 error (_("Cannot specify --frame without --thread"));
2199 if (parse->thread_group != -1)
2201 struct inferior *inf = find_inferior_id (parse->thread_group);
2202 struct thread_info *tp = 0;
2205 error (_("Invalid thread group for the --thread-group option"));
2207 set_current_inferior (inf);
2208 /* This behaviour means that if --thread-group option identifies
2209 an inferior with multiple threads, then a random one will be
2210 picked. This is not a problem -- frontend should always
2211 provide --thread if it wishes to operate on a specific
2214 tp = any_live_thread_of_process (inf->pid);
2215 switch_to_thread (tp ? tp->ptid : null_ptid);
2216 set_current_program_space (inf->pspace);
2219 if (parse->thread != -1)
2221 struct thread_info *tp = find_thread_global_id (parse->thread);
2224 error (_("Invalid thread id: %d"), parse->thread);
2226 if (is_exited (tp->ptid))
2227 error (_("Thread id: %d has terminated"), parse->thread);
2229 switch_to_thread (tp->ptid);
2232 if (parse->frame != -1)
2234 struct frame_info *fid;
2235 int frame = parse->frame;
2237 fid = find_relative_frame (get_current_frame (), &frame);
2239 /* find_relative_frame was successful */
2242 error (_("Invalid frame id: %d"), frame);
2245 if (parse->language != language_unknown)
2247 make_cleanup_restore_current_language ();
2248 set_language (parse->language);
2251 current_context = parse;
2253 if (parse->cmd->argv_func != NULL)
2255 parse->cmd->argv_func (parse->command, parse->argv, parse->argc);
2257 else if (parse->cmd->cli.cmd != 0)
2259 /* FIXME: DELETE THIS. */
2260 /* The operation is still implemented by a cli command. */
2261 /* Must be a synchronous one. */
2262 mi_execute_cli_command (parse->cmd->cli.cmd, parse->cmd->cli.args_p,
2267 /* FIXME: DELETE THIS. */
2270 stb.puts ("Undefined mi command: ");
2271 stb.putstr (parse->command, '"');
2272 stb.puts (" (missing implementation)");
2276 do_cleanups (cleanup);
2279 /* FIXME: This is just a hack so we can get some extra commands going.
2280 We don't want to channel things through the CLI, but call libgdb directly.
2281 Use only for synchronous commands. */
2284 mi_execute_cli_command (const char *cmd, int args_p, const char *args)
2288 struct cleanup *old_cleanups;
2292 run = xstrprintf ("%s %s", cmd, args);
2294 run = xstrdup (cmd);
2296 /* FIXME: gdb_???? */
2297 fprintf_unfiltered (gdb_stdout, "cli=%s run=%s\n",
2299 old_cleanups = make_cleanup (xfree, run);
2300 execute_command (run, 0 /* from_tty */ );
2301 do_cleanups (old_cleanups);
2307 mi_execute_async_cli_command (const char *cli_command, char **argv, int argc)
2309 struct cleanup *old_cleanups;
2313 run = xstrprintf ("%s %s&", cli_command, argc ? *argv : "");
2315 run = xstrprintf ("%s %s", cli_command, argc ? *argv : "");
2316 old_cleanups = make_cleanup (xfree, run);
2318 execute_command (run, 0 /* from_tty */ );
2320 /* Do this before doing any printing. It would appear that some
2321 print code leaves garbage around in the buffer. */
2322 do_cleanups (old_cleanups);
2326 mi_load_progress (const char *section_name,
2327 unsigned long sent_so_far,
2328 unsigned long total_section,
2329 unsigned long total_sent,
2330 unsigned long grand_total)
2332 using namespace std::chrono;
2333 static steady_clock::time_point last_update;
2334 static char *previous_sect_name = NULL;
2336 struct ui_out *saved_uiout;
2337 struct ui_out *uiout;
2338 struct mi_interp *mi = (struct mi_interp *) current_interpreter ();
2340 /* This function is called through deprecated_show_load_progress
2341 which means uiout may not be correct. Fix it for the duration
2342 of this function. */
2343 saved_uiout = current_uiout;
2345 if (current_interp_named_p (INTERP_MI)
2346 || current_interp_named_p (INTERP_MI2))
2347 current_uiout = mi_out_new (2);
2348 else if (current_interp_named_p (INTERP_MI1))
2349 current_uiout = mi_out_new (1);
2350 else if (current_interp_named_p (INTERP_MI3))
2351 current_uiout = mi_out_new (3);
2355 uiout = current_uiout;
2357 new_section = (previous_sect_name ?
2358 strcmp (previous_sect_name, section_name) : 1);
2361 xfree (previous_sect_name);
2362 previous_sect_name = xstrdup (section_name);
2365 fputs_unfiltered (current_token, mi->raw_stdout);
2366 fputs_unfiltered ("+download", mi->raw_stdout);
2368 ui_out_emit_tuple tuple_emitter (uiout, NULL);
2369 uiout->field_string ("section", section_name);
2370 uiout->field_int ("section-size", total_section);
2371 uiout->field_int ("total-size", grand_total);
2373 mi_out_put (uiout, mi->raw_stdout);
2374 fputs_unfiltered ("\n", mi->raw_stdout);
2375 gdb_flush (mi->raw_stdout);
2378 steady_clock::time_point time_now = steady_clock::now ();
2379 if (time_now - last_update > milliseconds (500))
2381 last_update = time_now;
2383 fputs_unfiltered (current_token, mi->raw_stdout);
2384 fputs_unfiltered ("+download", mi->raw_stdout);
2386 ui_out_emit_tuple tuple_emitter (uiout, NULL);
2387 uiout->field_string ("section", section_name);
2388 uiout->field_int ("section-sent", sent_so_far);
2389 uiout->field_int ("section-size", total_section);
2390 uiout->field_int ("total-sent", total_sent);
2391 uiout->field_int ("total-size", grand_total);
2393 mi_out_put (uiout, mi->raw_stdout);
2394 fputs_unfiltered ("\n", mi->raw_stdout);
2395 gdb_flush (mi->raw_stdout);
2399 current_uiout = saved_uiout;
2403 timestamp (struct mi_timestamp *tv)
2405 using namespace std::chrono;
2407 tv->wallclock = steady_clock::now ();
2408 run_time_clock::now (tv->utime, tv->stime);
2412 print_diff_now (struct ui_file *file, struct mi_timestamp *start)
2414 struct mi_timestamp now;
2417 print_diff (file, start, &now);
2421 mi_print_timing_maybe (struct ui_file *file)
2423 /* If the command is -enable-timing then do_timings may be true
2424 whilst current_command_ts is not initialized. */
2425 if (do_timings && current_command_ts)
2426 print_diff_now (file, current_command_ts);
2430 print_diff (struct ui_file *file, struct mi_timestamp *start,
2431 struct mi_timestamp *end)
2433 using namespace std::chrono;
2435 duration<double> wallclock = end->wallclock - start->wallclock;
2436 duration<double> utime = end->utime - start->utime;
2437 duration<double> stime = end->stime - start->stime;
2441 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
2442 wallclock.count (), utime.count (), stime.count ());
2446 mi_cmd_trace_define_variable (const char *command, char **argv, int argc)
2448 LONGEST initval = 0;
2449 struct trace_state_variable *tsv;
2452 if (argc != 1 && argc != 2)
2453 error (_("Usage: -trace-define-variable VARIABLE [VALUE]"));
2457 error (_("Name of trace variable should start with '$'"));
2459 validate_trace_state_variable_name (name);
2461 tsv = find_trace_state_variable (name);
2463 tsv = create_trace_state_variable (name);
2466 initval = value_as_long (parse_and_eval (argv[1]));
2468 tsv->initial_value = initval;
2472 mi_cmd_trace_list_variables (const char *command, char **argv, int argc)
2475 error (_("-trace-list-variables: no arguments allowed"));
2477 tvariables_info_1 ();
2481 mi_cmd_trace_find (const char *command, char **argv, int argc)
2486 error (_("trace selection mode is required"));
2490 if (strcmp (mode, "none") == 0)
2492 tfind_1 (tfind_number, -1, 0, 0, 0);
2496 check_trace_running (current_trace_status ());
2498 if (strcmp (mode, "frame-number") == 0)
2501 error (_("frame number is required"));
2502 tfind_1 (tfind_number, atoi (argv[1]), 0, 0, 0);
2504 else if (strcmp (mode, "tracepoint-number") == 0)
2507 error (_("tracepoint number is required"));
2508 tfind_1 (tfind_tp, atoi (argv[1]), 0, 0, 0);
2510 else if (strcmp (mode, "pc") == 0)
2513 error (_("PC is required"));
2514 tfind_1 (tfind_pc, 0, parse_and_eval_address (argv[1]), 0, 0);
2516 else if (strcmp (mode, "pc-inside-range") == 0)
2519 error (_("Start and end PC are required"));
2520 tfind_1 (tfind_range, 0, parse_and_eval_address (argv[1]),
2521 parse_and_eval_address (argv[2]), 0);
2523 else if (strcmp (mode, "pc-outside-range") == 0)
2526 error (_("Start and end PC are required"));
2527 tfind_1 (tfind_outside, 0, parse_and_eval_address (argv[1]),
2528 parse_and_eval_address (argv[2]), 0);
2530 else if (strcmp (mode, "line") == 0)
2532 struct symtabs_and_lines sals;
2533 struct symtab_and_line sal;
2534 static CORE_ADDR start_pc, end_pc;
2535 struct cleanup *back_to;
2538 error (_("Line is required"));
2540 sals = decode_line_with_current_source (argv[1],
2541 DECODE_LINE_FUNFIRSTLINE);
2542 back_to = make_cleanup (xfree, sals.sals);
2546 if (sal.symtab == 0)
2547 error (_("Could not find the specified line"));
2549 if (sal.line > 0 && find_line_pc_range (sal, &start_pc, &end_pc))
2550 tfind_1 (tfind_range, 0, start_pc, end_pc - 1, 0);
2552 error (_("Could not find the specified line"));
2554 do_cleanups (back_to);
2557 error (_("Invalid mode '%s'"), mode);
2559 if (has_stack_frames () || get_traceframe_number () >= 0)
2560 print_stack_frame (get_selected_frame (NULL), 1, LOC_AND_ADDRESS, 1);
2564 mi_cmd_trace_save (const char *command, char **argv, int argc)
2566 int target_saves = 0;
2567 int generate_ctf = 0;
2574 TARGET_SAVE_OPT, CTF_OPT
2576 static const struct mi_opt opts[] =
2578 {"r", TARGET_SAVE_OPT, 0},
2579 {"ctf", CTF_OPT, 0},
2585 int opt = mi_getopt ("-trace-save", argc, argv, opts,
2590 switch ((enum opt) opt)
2592 case TARGET_SAVE_OPT:
2601 if (argc - oind != 1)
2602 error (_("Exactly one argument required "
2603 "(file in which to save trace data)"));
2605 filename = argv[oind];
2608 trace_save_ctf (filename, target_saves);
2610 trace_save_tfile (filename, target_saves);
2614 mi_cmd_trace_start (const char *command, char **argv, int argc)
2616 start_tracing (NULL);
2620 mi_cmd_trace_status (const char *command, char **argv, int argc)
2622 trace_status_mi (0);
2626 mi_cmd_trace_stop (const char *command, char **argv, int argc)
2628 stop_tracing (NULL);
2629 trace_status_mi (1);
2632 /* Implement the "-ada-task-info" command. */
2635 mi_cmd_ada_task_info (const char *command, char **argv, int argc)
2637 if (argc != 0 && argc != 1)
2638 error (_("Invalid MI command"));
2640 print_ada_task_info (current_uiout, argv[0], current_inferior ());
2643 /* Print EXPRESSION according to VALUES. */
2646 print_variable_or_computed (const char *expression, enum print_values values)
2650 struct ui_out *uiout = current_uiout;
2654 expression_up expr = parse_expression (expression);
2656 if (values == PRINT_SIMPLE_VALUES)
2657 val = evaluate_type (expr.get ());
2659 val = evaluate_expression (expr.get ());
2661 gdb::optional<ui_out_emit_tuple> tuple_emitter;
2662 if (values != PRINT_NO_VALUES)
2663 tuple_emitter.emplace (uiout, nullptr);
2664 uiout->field_string ("name", expression);
2668 case PRINT_SIMPLE_VALUES:
2669 type = check_typedef (value_type (val));
2670 type_print (value_type (val), "", &stb, -1);
2671 uiout->field_stream ("type", stb);
2672 if (TYPE_CODE (type) != TYPE_CODE_ARRAY
2673 && TYPE_CODE (type) != TYPE_CODE_STRUCT
2674 && TYPE_CODE (type) != TYPE_CODE_UNION)
2676 struct value_print_options opts;
2678 get_no_prettyformat_print_options (&opts);
2680 common_val_print (val, &stb, 0, &opts, current_language);
2681 uiout->field_stream ("value", stb);
2684 case PRINT_ALL_VALUES:
2686 struct value_print_options opts;
2688 get_no_prettyformat_print_options (&opts);
2690 common_val_print (val, &stb, 0, &opts, current_language);
2691 uiout->field_stream ("value", stb);
2697 /* Implement the "-trace-frame-collected" command. */
2700 mi_cmd_trace_frame_collected (const char *command, char **argv, int argc)
2702 struct cleanup *old_chain;
2703 struct bp_location *tloc;
2705 struct collection_list *clist;
2706 struct collection_list tracepoint_list, stepping_list;
2707 struct traceframe_info *tinfo;
2709 enum print_values var_print_values = PRINT_ALL_VALUES;
2710 enum print_values comp_print_values = PRINT_ALL_VALUES;
2711 int registers_format = 'x';
2712 int memory_contents = 0;
2713 struct ui_out *uiout = current_uiout;
2721 static const struct mi_opt opts[] =
2723 {"-var-print-values", VAR_PRINT_VALUES, 1},
2724 {"-comp-print-values", COMP_PRINT_VALUES, 1},
2725 {"-registers-format", REGISTERS_FORMAT, 1},
2726 {"-memory-contents", MEMORY_CONTENTS, 0},
2733 int opt = mi_getopt ("-trace-frame-collected", argc, argv, opts,
2737 switch ((enum opt) opt)
2739 case VAR_PRINT_VALUES:
2740 var_print_values = mi_parse_print_values (oarg);
2742 case COMP_PRINT_VALUES:
2743 comp_print_values = mi_parse_print_values (oarg);
2745 case REGISTERS_FORMAT:
2746 registers_format = oarg[0];
2747 case MEMORY_CONTENTS:
2748 memory_contents = 1;
2754 error (_("Usage: -trace-frame-collected "
2755 "[--var-print-values PRINT_VALUES] "
2756 "[--comp-print-values PRINT_VALUES] "
2757 "[--registers-format FORMAT]"
2758 "[--memory-contents]"));
2760 /* This throws an error is not inspecting a trace frame. */
2761 tloc = get_traceframe_location (&stepping_frame);
2763 /* This command only makes sense for the current frame, not the
2765 old_chain = make_cleanup_restore_current_thread ();
2766 select_frame (get_current_frame ());
2768 encode_actions (tloc, &tracepoint_list, &stepping_list);
2771 clist = &stepping_list;
2773 clist = &tracepoint_list;
2775 tinfo = get_traceframe_info ();
2777 /* Explicitly wholly collected variables. */
2781 ui_out_emit_list list_emitter (uiout, "explicit-variables");
2782 const std::vector<std::string> &wholly_collected
2783 = clist->wholly_collected ();
2784 for (size_t i = 0; i < wholly_collected.size (); i++)
2786 const std::string &str = wholly_collected[i];
2787 print_variable_or_computed (str.c_str (), var_print_values);
2791 /* Computed expressions. */
2796 ui_out_emit_list list_emitter (uiout, "computed-expressions");
2798 const std::vector<std::string> &computed = clist->computed ();
2799 for (size_t i = 0; i < computed.size (); i++)
2801 const std::string &str = computed[i];
2802 print_variable_or_computed (str.c_str (), comp_print_values);
2806 /* Registers. Given pseudo-registers, and that some architectures
2807 (like MIPS) actually hide the raw registers, we don't go through
2808 the trace frame info, but instead consult the register cache for
2809 register availability. */
2811 struct frame_info *frame;
2812 struct gdbarch *gdbarch;
2816 ui_out_emit_list list_emitter (uiout, "registers");
2818 frame = get_selected_frame (NULL);
2819 gdbarch = get_frame_arch (frame);
2820 numregs = gdbarch_num_regs (gdbarch) + gdbarch_num_pseudo_regs (gdbarch);
2822 for (regnum = 0; regnum < numregs; regnum++)
2824 if (gdbarch_register_name (gdbarch, regnum) == NULL
2825 || *(gdbarch_register_name (gdbarch, regnum)) == '\0')
2828 output_register (frame, regnum, registers_format, 1);
2832 /* Trace state variables. */
2834 struct cleanup *list_cleanup;
2839 list_cleanup = make_cleanup_ui_out_list_begin_end (uiout, "tvars");
2842 make_cleanup (free_current_contents, &tsvname);
2844 for (i = 0; VEC_iterate (int, tinfo->tvars, i, tvar); i++)
2846 struct trace_state_variable *tsv;
2848 tsv = find_trace_state_variable_by_number (tvar);
2850 ui_out_emit_tuple tuple_emitter (uiout, NULL);
2854 tsvname = (char *) xrealloc (tsvname, strlen (tsv->name) + 2);
2856 strcpy (tsvname + 1, tsv->name);
2857 uiout->field_string ("name", tsvname);
2859 tsv->value_known = target_get_trace_state_variable_value (tsv->number,
2861 uiout->field_int ("current", tsv->value);
2865 uiout->field_skip ("name");
2866 uiout->field_skip ("current");
2870 do_cleanups (list_cleanup);
2875 struct cleanup *list_cleanup;
2876 VEC(mem_range_s) *available_memory = NULL;
2877 struct mem_range *r;
2880 traceframe_available_memory (&available_memory, 0, ULONGEST_MAX);
2881 make_cleanup (VEC_cleanup(mem_range_s), &available_memory);
2883 list_cleanup = make_cleanup_ui_out_list_begin_end (uiout, "memory");
2885 for (i = 0; VEC_iterate (mem_range_s, available_memory, i, r); i++)
2887 struct cleanup *cleanup_child;
2889 struct gdbarch *gdbarch = target_gdbarch ();
2891 cleanup_child = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
2893 uiout->field_core_addr ("address", gdbarch, r->start);
2894 uiout->field_int ("length", r->length);
2896 data = (gdb_byte *) xmalloc (r->length);
2897 make_cleanup (xfree, data);
2899 if (memory_contents)
2901 if (target_read_memory (r->start, data, r->length) == 0)
2906 data_str = (char *) xmalloc (r->length * 2 + 1);
2907 make_cleanup (xfree, data_str);
2909 for (m = 0, p = data_str; m < r->length; ++m, p += 2)
2910 sprintf (p, "%02x", data[m]);
2911 uiout->field_string ("contents", data_str);
2914 uiout->field_skip ("contents");
2916 do_cleanups (cleanup_child);
2919 do_cleanups (list_cleanup);
2922 do_cleanups (old_chain);
2926 _initialize_mi_main (void)
2928 struct cmd_list_element *c;
2930 add_setshow_boolean_cmd ("mi-async", class_run,
2932 Set whether MI asynchronous mode is enabled."), _("\
2933 Show whether MI asynchronous mode is enabled."), _("\
2934 Tells GDB whether MI should be in asynchronous mode."),
2935 set_mi_async_command,
2936 show_mi_async_command,
2940 /* Alias old "target-async" to "mi-async". */
2941 c = add_alias_cmd ("target-async", "mi-async", class_run, 0, &setlist);
2942 deprecate_cmd (c, "set mi-async");
2943 c = add_alias_cmd ("target-async", "mi-async", class_run, 0, &showlist);
2944 deprecate_cmd (c, "show mi-async");