3 Copyright (C) 2000-2019 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(). */
43 #include "mi-common.h"
48 #include "common/gdb_splay_tree.h"
49 #include "tracepoint.h"
53 #include "extension.h"
55 #include "observable.h"
56 #include "common/gdb_optional.h"
57 #include "common/byte-vector.h"
60 #include "run-time-clock.h"
62 #include "progspace-and-thread.h"
63 #include "common/rsp-low.h"
75 /* This is used to pass the current command timestamp down to
76 continuation routines. */
77 static struct mi_timestamp
*current_command_ts
;
79 static int do_timings
= 0;
82 /* Few commands would like to know if options like --thread-group were
83 explicitly specified. This variable keeps the current parsed
84 command including all option, and make it possible. */
85 static struct mi_parse
*current_context
;
87 int running_result_record_printed
= 1;
89 /* Flag indicating that the target has proceeded since the last
90 command was issued. */
93 static void mi_cmd_execute (struct mi_parse
*parse
);
95 static void mi_execute_cli_command (const char *cmd
, int args_p
,
97 static void mi_execute_async_cli_command (const char *cli_command
,
98 char **argv
, int argc
);
99 static bool register_changed_p (int regnum
, readonly_detached_regcache
*,
100 readonly_detached_regcache
*);
101 static void output_register (struct frame_info
*, int regnum
, int format
,
102 int skip_unavailable
);
104 /* Controls whether the frontend wants MI in async mode. */
105 static int mi_async
= 0;
107 /* The set command writes to this variable. If the inferior is
108 executing, mi_async is *not* updated. */
109 static int mi_async_1
= 0;
112 set_mi_async_command (const char *args
, int from_tty
,
113 struct cmd_list_element
*c
)
115 if (have_live_inferiors ())
117 mi_async_1
= mi_async
;
118 error (_("Cannot change this setting while the inferior is running."));
121 mi_async
= mi_async_1
;
125 show_mi_async_command (struct ui_file
*file
, int from_tty
,
126 struct cmd_list_element
*c
,
129 fprintf_filtered (file
,
130 _("Whether MI is in asynchronous mode is %s.\n"),
134 /* A wrapper for target_can_async_p that takes the MI setting into
140 return mi_async
&& target_can_async_p ();
143 /* Command implementations. FIXME: Is this libgdb? No. This is the MI
144 layer that calls libgdb. Any operation used in the below should be
147 static void timestamp (struct mi_timestamp
*tv
);
149 static void print_diff (struct ui_file
*file
, struct mi_timestamp
*start
,
150 struct mi_timestamp
*end
);
153 mi_cmd_gdb_exit (const char *command
, char **argv
, int argc
)
155 struct mi_interp
*mi
= (struct mi_interp
*) current_interpreter ();
157 /* We have to print everything right here because we never return. */
159 fputs_unfiltered (current_token
, mi
->raw_stdout
);
160 fputs_unfiltered ("^exit\n", mi
->raw_stdout
);
161 mi_out_put (current_uiout
, mi
->raw_stdout
);
162 gdb_flush (mi
->raw_stdout
);
163 /* FIXME: The function called is not yet a formal libgdb function. */
164 quit_force (NULL
, FROM_TTY
);
168 mi_cmd_exec_next (const char *command
, char **argv
, int argc
)
170 /* FIXME: Should call a libgdb function, not a cli wrapper. */
171 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
172 mi_execute_async_cli_command ("reverse-next", argv
+ 1, argc
- 1);
174 mi_execute_async_cli_command ("next", argv
, argc
);
178 mi_cmd_exec_next_instruction (const char *command
, char **argv
, int argc
)
180 /* FIXME: Should call a libgdb function, not a cli wrapper. */
181 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
182 mi_execute_async_cli_command ("reverse-nexti", argv
+ 1, argc
- 1);
184 mi_execute_async_cli_command ("nexti", argv
, argc
);
188 mi_cmd_exec_step (const char *command
, char **argv
, int argc
)
190 /* FIXME: Should call a libgdb function, not a cli wrapper. */
191 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
192 mi_execute_async_cli_command ("reverse-step", argv
+ 1, argc
- 1);
194 mi_execute_async_cli_command ("step", argv
, argc
);
198 mi_cmd_exec_step_instruction (const char *command
, char **argv
, int argc
)
200 /* FIXME: Should call a libgdb function, not a cli wrapper. */
201 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
202 mi_execute_async_cli_command ("reverse-stepi", argv
+ 1, argc
- 1);
204 mi_execute_async_cli_command ("stepi", argv
, argc
);
208 mi_cmd_exec_finish (const char *command
, char **argv
, int argc
)
210 /* FIXME: Should call a libgdb function, not a cli wrapper. */
211 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
212 mi_execute_async_cli_command ("reverse-finish", argv
+ 1, argc
- 1);
214 mi_execute_async_cli_command ("finish", argv
, argc
);
218 mi_cmd_exec_return (const char *command
, char **argv
, int argc
)
220 /* This command doesn't really execute the target, it just pops the
221 specified number of frames. */
223 /* Call return_command with from_tty argument equal to 0 so as to
224 avoid being queried. */
225 return_command (*argv
, 0);
227 /* Call return_command with from_tty argument equal to 0 so as to
228 avoid being queried. */
229 return_command (NULL
, 0);
231 /* Because we have called return_command with from_tty = 0, we need
232 to print the frame here. */
233 print_stack_frame (get_selected_frame (NULL
), 1, LOC_AND_ADDRESS
, 1);
237 mi_cmd_exec_jump (const char *args
, char **argv
, int argc
)
239 /* FIXME: Should call a libgdb function, not a cli wrapper. */
240 mi_execute_async_cli_command ("jump", argv
, argc
);
244 proceed_thread (struct thread_info
*thread
, int pid
)
246 if (thread
->state
!= THREAD_STOPPED
)
249 if (pid
!= 0 && thread
->ptid
.pid () != pid
)
252 switch_to_thread (thread
);
253 clear_proceed_status (0);
254 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
);
258 proceed_thread_callback (struct thread_info
*thread
, void *arg
)
260 int pid
= *(int *)arg
;
262 proceed_thread (thread
, pid
);
267 exec_continue (char **argv
, int argc
)
269 prepare_execution_command (current_top_target (), mi_async_p ());
273 /* In non-stop mode, 'resume' always resumes a single thread.
274 Therefore, to resume all threads of the current inferior, or
275 all threads in all inferiors, we need to iterate over
278 See comment on infcmd.c:proceed_thread_callback for rationale. */
279 if (current_context
->all
|| current_context
->thread_group
!= -1)
281 scoped_restore_current_thread restore_thread
;
284 if (!current_context
->all
)
287 = find_inferior_id (current_context
->thread_group
);
291 iterate_over_threads (proceed_thread_callback
, &pid
);
300 scoped_restore save_multi
= make_scoped_restore (&sched_multi
);
302 if (current_context
->all
)
309 /* In all-stop mode, -exec-continue traditionally resumed
310 either all threads, or one thread, depending on the
311 'scheduler-locking' variable. Let's continue to do the
319 exec_reverse_continue (char **argv
, int argc
)
321 enum exec_direction_kind dir
= execution_direction
;
323 if (dir
== EXEC_REVERSE
)
324 error (_("Already in reverse mode."));
326 if (!target_can_execute_reverse
)
327 error (_("Target %s does not support this command."), target_shortname
);
329 scoped_restore save_exec_dir
= make_scoped_restore (&execution_direction
,
331 exec_continue (argv
, argc
);
335 mi_cmd_exec_continue (const char *command
, char **argv
, int argc
)
337 if (argc
> 0 && strcmp (argv
[0], "--reverse") == 0)
338 exec_reverse_continue (argv
+ 1, argc
- 1);
340 exec_continue (argv
, argc
);
344 interrupt_thread_callback (struct thread_info
*thread
, void *arg
)
346 int pid
= *(int *)arg
;
348 if (thread
->state
!= THREAD_RUNNING
)
351 if (thread
->ptid
.pid () != pid
)
354 target_stop (thread
->ptid
);
358 /* Interrupt the execution of the target. Note how we must play
359 around with the token variables, in order to display the current
360 token in the result of the interrupt command, and the previous
361 execution token when the target finally stops. See comments in
365 mi_cmd_exec_interrupt (const char *command
, char **argv
, int argc
)
367 /* In all-stop mode, everything stops, so we don't need to try
368 anything specific. */
371 interrupt_target_1 (0);
375 if (current_context
->all
)
377 /* This will interrupt all threads in all inferiors. */
378 interrupt_target_1 (1);
380 else if (current_context
->thread_group
!= -1)
382 struct inferior
*inf
= find_inferior_id (current_context
->thread_group
);
384 iterate_over_threads (interrupt_thread_callback
, &inf
->pid
);
388 /* Interrupt just the current thread -- either explicitly
389 specified via --thread or whatever was current before
390 MI command was sent. */
391 interrupt_target_1 (0);
395 /* Callback for iterate_over_inferiors which starts the execution
396 of the given inferior.
398 ARG is a pointer to an integer whose value, if non-zero, indicates
399 that the program should be stopped when reaching the main subprogram
400 (similar to what the CLI "start" command does). */
403 run_one_inferior (struct inferior
*inf
, void *arg
)
405 int start_p
= *(int *) arg
;
406 const char *run_cmd
= start_p
? "start" : "run";
407 struct target_ops
*run_target
= find_run_target ();
408 int async_p
= mi_async
&& run_target
->can_async_p ();
412 thread_info
*tp
= any_thread_of_inferior (inf
);
414 error (_("Inferior has no threads."));
416 switch_to_thread (tp
);
420 set_current_inferior (inf
);
421 switch_to_no_thread ();
422 set_current_program_space (inf
->pspace
);
424 mi_execute_cli_command (run_cmd
, async_p
,
425 async_p
? "&" : NULL
);
430 mi_cmd_exec_run (const char *command
, char **argv
, int argc
)
434 /* Parse the command options. */
439 static const struct mi_opt opts
[] =
441 {"-start", START_OPT
, 0},
450 int opt
= mi_getopt ("-exec-run", argc
, argv
, opts
, &oind
, &oarg
);
454 switch ((enum opt
) opt
)
462 /* This command does not accept any argument. Make sure the user
463 did not provide any. */
465 error (_("Invalid argument: %s"), argv
[oind
]);
467 if (current_context
->all
)
469 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
471 iterate_over_inferiors (run_one_inferior
, &start_p
);
475 const char *run_cmd
= start_p
? "start" : "run";
476 struct target_ops
*run_target
= find_run_target ();
477 int async_p
= mi_async
&& run_target
->can_async_p ();
479 mi_execute_cli_command (run_cmd
, async_p
,
480 async_p
? "&" : NULL
);
486 find_thread_of_process (struct thread_info
*ti
, void *p
)
490 if (ti
->ptid
.pid () == pid
&& ti
->state
!= THREAD_EXITED
)
497 mi_cmd_target_detach (const char *command
, char **argv
, int argc
)
499 if (argc
!= 0 && argc
!= 1)
500 error (_("Usage: -target-detach [pid | thread-group]"));
504 struct thread_info
*tp
;
508 /* First see if we are dealing with a thread-group id. */
511 struct inferior
*inf
;
512 int id
= strtoul (argv
[0] + 1, &end
, 0);
515 error (_("Invalid syntax of thread-group id '%s'"), argv
[0]);
517 inf
= find_inferior_id (id
);
519 error (_("Non-existent thread-group id '%d'"), id
);
525 /* We must be dealing with a pid. */
526 pid
= strtol (argv
[0], &end
, 10);
529 error (_("Invalid identifier '%s'"), argv
[0]);
532 /* Pick any thread in the desired process. Current
533 target_detach detaches from the parent of inferior_ptid. */
534 tp
= iterate_over_threads (find_thread_of_process
, &pid
);
536 error (_("Thread group is empty"));
538 switch_to_thread (tp
);
541 detach_command (NULL
, 0);
545 mi_cmd_target_flash_erase (const char *command
, char **argv
, int argc
)
547 flash_erase_command (NULL
, 0);
551 mi_cmd_thread_select (const char *command
, char **argv
, int argc
)
554 error (_("-thread-select: USAGE: threadnum."));
556 int num
= value_as_long (parse_and_eval (argv
[0]));
557 thread_info
*thr
= find_thread_global_id (num
);
559 error (_("Thread ID %d not known."), num
);
561 ptid_t previous_ptid
= inferior_ptid
;
563 thread_select (argv
[0], thr
);
565 print_selected_thread_frame (current_uiout
,
566 USER_SELECTED_THREAD
| USER_SELECTED_FRAME
);
568 /* Notify if the thread has effectively changed. */
569 if (inferior_ptid
!= previous_ptid
)
571 gdb::observers::user_selected_context_changed
.notify
572 (USER_SELECTED_THREAD
| USER_SELECTED_FRAME
);
577 mi_cmd_thread_list_ids (const char *command
, char **argv
, int argc
)
580 error (_("-thread-list-ids: No arguments required."));
583 int current_thread
= -1;
585 update_thread_list ();
588 ui_out_emit_tuple
tuple_emitter (current_uiout
, "thread-ids");
590 for (thread_info
*tp
: all_non_exited_threads ())
592 if (tp
->ptid
== inferior_ptid
)
593 current_thread
= tp
->global_num
;
596 current_uiout
->field_int ("thread-id", tp
->global_num
);
600 if (current_thread
!= -1)
601 current_uiout
->field_int ("current-thread-id", current_thread
);
602 current_uiout
->field_int ("number-of-threads", num
);
606 mi_cmd_thread_info (const char *command
, char **argv
, int argc
)
608 if (argc
!= 0 && argc
!= 1)
609 error (_("Invalid MI command"));
611 print_thread_info (current_uiout
, argv
[0], -1);
614 struct collect_cores_data
621 collect_cores (struct thread_info
*ti
, void *xdata
)
623 struct collect_cores_data
*data
= (struct collect_cores_data
*) xdata
;
625 if (ti
->ptid
.pid () == data
->pid
)
627 int core
= target_core_of_thread (ti
->ptid
);
630 data
->cores
.insert (core
);
636 struct print_one_inferior_data
639 const std::set
<int> *inferiors
;
643 print_one_inferior (struct inferior
*inferior
, void *xdata
)
645 struct print_one_inferior_data
*top_data
646 = (struct print_one_inferior_data
*) xdata
;
647 struct ui_out
*uiout
= current_uiout
;
649 if (top_data
->inferiors
->empty ()
650 || (top_data
->inferiors
->find (inferior
->pid
)
651 != top_data
->inferiors
->end ()))
653 struct collect_cores_data data
;
654 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
656 uiout
->field_fmt ("id", "i%d", inferior
->num
);
657 uiout
->field_string ("type", "process");
658 if (inferior
->has_exit_code
)
659 uiout
->field_string ("exit-code",
660 int_string (inferior
->exit_code
, 8, 0, 0, 1));
661 if (inferior
->pid
!= 0)
662 uiout
->field_int ("pid", inferior
->pid
);
664 if (inferior
->pspace
->pspace_exec_filename
!= NULL
)
666 uiout
->field_string ("executable",
667 inferior
->pspace
->pspace_exec_filename
);
670 if (inferior
->pid
!= 0)
672 data
.pid
= inferior
->pid
;
673 iterate_over_threads (collect_cores
, &data
);
676 if (!data
.cores
.empty ())
678 ui_out_emit_list
list_emitter (uiout
, "cores");
680 for (int b
: data
.cores
)
681 uiout
->field_int (NULL
, b
);
684 if (top_data
->recurse
)
685 print_thread_info (uiout
, NULL
, inferior
->pid
);
691 /* Output a field named 'cores' with a list as the value. The
692 elements of the list are obtained by splitting 'cores' on
696 output_cores (struct ui_out
*uiout
, const char *field_name
, const char *xcores
)
698 ui_out_emit_list
list_emitter (uiout
, field_name
);
699 gdb::unique_xmalloc_ptr
<char> cores (xstrdup (xcores
));
700 char *p
= cores
.get ();
702 for (p
= strtok (p
, ","); p
; p
= strtok (NULL
, ","))
703 uiout
->field_string (NULL
, p
);
707 list_available_thread_groups (const std::set
<int> &ids
, int recurse
)
709 struct ui_out
*uiout
= current_uiout
;
711 /* This keeps a map from integer (pid) to vector of struct osdata_item.
712 The vector contains information about all threads for the given pid. */
713 std::map
<int, std::vector
<osdata_item
>> tree
;
715 /* get_osdata will throw if it cannot return data. */
716 std::unique_ptr
<osdata
> data
= get_osdata ("processes");
720 std::unique_ptr
<osdata
> threads
= get_osdata ("threads");
722 for (const osdata_item
&item
: threads
->items
)
724 const std::string
*pid
= get_osdata_column (item
, "pid");
725 int pid_i
= strtoul (pid
->c_str (), NULL
, 0);
727 tree
[pid_i
].push_back (item
);
731 ui_out_emit_list
list_emitter (uiout
, "groups");
733 for (const osdata_item
&item
: data
->items
)
735 const std::string
*pid
= get_osdata_column (item
, "pid");
736 const std::string
*cmd
= get_osdata_column (item
, "command");
737 const std::string
*user
= get_osdata_column (item
, "user");
738 const std::string
*cores
= get_osdata_column (item
, "cores");
740 int pid_i
= strtoul (pid
->c_str (), NULL
, 0);
742 /* At present, the target will return all available processes
743 and if information about specific ones was required, we filter
744 undesired processes here. */
745 if (!ids
.empty () && ids
.find (pid_i
) == ids
.end ())
748 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
750 uiout
->field_fmt ("id", "%s", pid
->c_str ());
751 uiout
->field_string ("type", "process");
753 uiout
->field_string ("description", cmd
->c_str ());
755 uiout
->field_string ("user", user
->c_str ());
757 output_cores (uiout
, "cores", cores
->c_str ());
761 auto n
= tree
.find (pid_i
);
762 if (n
!= tree
.end ())
764 std::vector
<osdata_item
> &children
= n
->second
;
766 ui_out_emit_list
thread_list_emitter (uiout
, "threads");
768 for (const osdata_item
&child
: children
)
770 ui_out_emit_tuple
inner_tuple_emitter (uiout
, NULL
);
771 const std::string
*tid
= get_osdata_column (child
, "tid");
772 const std::string
*tcore
= get_osdata_column (child
, "core");
774 uiout
->field_string ("id", tid
->c_str ());
776 uiout
->field_string ("core", tcore
->c_str ());
784 mi_cmd_list_thread_groups (const char *command
, char **argv
, int argc
)
786 struct ui_out
*uiout
= current_uiout
;
793 AVAILABLE_OPT
, RECURSE_OPT
795 static const struct mi_opt opts
[] =
797 {"-available", AVAILABLE_OPT
, 0},
798 {"-recurse", RECURSE_OPT
, 1},
807 int opt
= mi_getopt ("-list-thread-groups", argc
, argv
, opts
,
812 switch ((enum opt
) opt
)
818 if (strcmp (oarg
, "0") == 0)
820 else if (strcmp (oarg
, "1") == 0)
823 error (_("only '0' and '1' are valid values "
824 "for the '--recurse' option"));
829 for (; oind
< argc
; ++oind
)
834 if (*(argv
[oind
]) != 'i')
835 error (_("invalid syntax of group id '%s'"), argv
[oind
]);
837 inf
= strtoul (argv
[oind
] + 1, &end
, 0);
840 error (_("invalid syntax of group id '%s'"), argv
[oind
]);
846 list_available_thread_groups (ids
, recurse
);
848 else if (ids
.size () == 1)
850 /* Local thread groups, single id. */
851 int id
= *(ids
.begin ());
852 struct inferior
*inf
= find_inferior_id (id
);
855 error (_("Non-existent thread group id '%d'"), id
);
857 print_thread_info (uiout
, NULL
, inf
->pid
);
861 struct print_one_inferior_data data
;
863 data
.recurse
= recurse
;
864 data
.inferiors
= &ids
;
866 /* Local thread groups. Either no explicit ids -- and we
867 print everything, or several explicit ids. In both cases,
868 we print more than one group, and have to use 'groups'
869 as the top-level element. */
870 ui_out_emit_list
list_emitter (uiout
, "groups");
871 update_thread_list ();
872 iterate_over_inferiors (print_one_inferior
, &data
);
877 mi_cmd_data_list_register_names (const char *command
, char **argv
, int argc
)
879 struct gdbarch
*gdbarch
;
880 struct ui_out
*uiout
= current_uiout
;
884 /* Note that the test for a valid register must include checking the
885 gdbarch_register_name because gdbarch_num_regs may be allocated
886 for the union of the register sets within a family of related
887 processors. In this case, some entries of gdbarch_register_name
888 will change depending upon the particular processor being
891 gdbarch
= get_current_arch ();
892 numregs
= gdbarch_num_cooked_regs (gdbarch
);
894 ui_out_emit_list
list_emitter (uiout
, "register-names");
896 if (argc
== 0) /* No args, just do all the regs. */
902 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
903 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
904 uiout
->field_string (NULL
, "");
906 uiout
->field_string (NULL
, gdbarch_register_name (gdbarch
, regnum
));
910 /* Else, list of register #s, just do listed regs. */
911 for (i
= 0; i
< argc
; i
++)
913 regnum
= atoi (argv
[i
]);
914 if (regnum
< 0 || regnum
>= numregs
)
915 error (_("bad register number"));
917 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
918 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
919 uiout
->field_string (NULL
, "");
921 uiout
->field_string (NULL
, gdbarch_register_name (gdbarch
, regnum
));
926 mi_cmd_data_list_changed_registers (const char *command
, char **argv
, int argc
)
928 static std::unique_ptr
<readonly_detached_regcache
> this_regs
;
929 struct ui_out
*uiout
= current_uiout
;
930 std::unique_ptr
<readonly_detached_regcache
> prev_regs
;
931 struct gdbarch
*gdbarch
;
935 /* The last time we visited this function, the current frame's
936 register contents were saved in THIS_REGS. Move THIS_REGS over
937 to PREV_REGS, and refresh THIS_REGS with the now-current register
940 prev_regs
= std::move (this_regs
);
941 this_regs
= frame_save_as_regcache (get_selected_frame (NULL
));
943 /* Note that the test for a valid register must include checking the
944 gdbarch_register_name because gdbarch_num_regs may be allocated
945 for the union of the register sets within a family of related
946 processors. In this case, some entries of gdbarch_register_name
947 will change depending upon the particular processor being
950 gdbarch
= this_regs
->arch ();
951 numregs
= gdbarch_num_cooked_regs (gdbarch
);
953 ui_out_emit_list
list_emitter (uiout
, "changed-registers");
957 /* No args, just do all the regs. */
962 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
963 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
966 if (register_changed_p (regnum
, prev_regs
.get (),
968 uiout
->field_int (NULL
, regnum
);
972 /* Else, list of register #s, just do listed regs. */
973 for (i
= 0; i
< argc
; i
++)
975 regnum
= atoi (argv
[i
]);
979 && gdbarch_register_name (gdbarch
, regnum
) != NULL
980 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
982 if (register_changed_p (regnum
, prev_regs
.get (),
984 uiout
->field_int (NULL
, regnum
);
987 error (_("bad register number"));
992 register_changed_p (int regnum
, readonly_detached_regcache
*prev_regs
,
993 readonly_detached_regcache
*this_regs
)
995 struct gdbarch
*gdbarch
= this_regs
->arch ();
996 struct value
*prev_value
, *this_value
;
998 /* First time through or after gdbarch change consider all registers
1000 if (!prev_regs
|| prev_regs
->arch () != gdbarch
)
1003 /* Get register contents and compare. */
1004 prev_value
= prev_regs
->cooked_read_value (regnum
);
1005 this_value
= this_regs
->cooked_read_value (regnum
);
1006 gdb_assert (prev_value
!= NULL
);
1007 gdb_assert (this_value
!= NULL
);
1009 auto ret
= !value_contents_eq (prev_value
, 0, this_value
, 0,
1010 register_size (gdbarch
, regnum
));
1012 release_value (prev_value
);
1013 release_value (this_value
);
1017 /* Return a list of register number and value pairs. The valid
1018 arguments expected are: a letter indicating the format in which to
1019 display the registers contents. This can be one of: x
1020 (hexadecimal), d (decimal), N (natural), t (binary), o (octal), r
1021 (raw). After the format argument there can be a sequence of
1022 numbers, indicating which registers to fetch the content of. If
1023 the format is the only argument, a list of all the registers with
1024 their values is returned. */
1027 mi_cmd_data_list_register_values (const char *command
, char **argv
, int argc
)
1029 struct ui_out
*uiout
= current_uiout
;
1030 struct frame_info
*frame
;
1031 struct gdbarch
*gdbarch
;
1032 int regnum
, numregs
, format
;
1034 int skip_unavailable
= 0;
1040 static const struct mi_opt opts
[] =
1042 {"-skip-unavailable", SKIP_UNAVAILABLE
, 0},
1046 /* Note that the test for a valid register must include checking the
1047 gdbarch_register_name because gdbarch_num_regs may be allocated
1048 for the union of the register sets within a family of related
1049 processors. In this case, some entries of gdbarch_register_name
1050 will change depending upon the particular processor being
1056 int opt
= mi_getopt ("-data-list-register-values", argc
, argv
,
1057 opts
, &oind
, &oarg
);
1061 switch ((enum opt
) opt
)
1063 case SKIP_UNAVAILABLE
:
1064 skip_unavailable
= 1;
1069 if (argc
- oind
< 1)
1070 error (_("-data-list-register-values: Usage: "
1071 "-data-list-register-values [--skip-unavailable] <format>"
1072 " [<regnum1>...<regnumN>]"));
1074 format
= (int) argv
[oind
][0];
1076 frame
= get_selected_frame (NULL
);
1077 gdbarch
= get_frame_arch (frame
);
1078 numregs
= gdbarch_num_cooked_regs (gdbarch
);
1080 ui_out_emit_list
list_emitter (uiout
, "register-values");
1082 if (argc
- oind
== 1)
1084 /* No args, beside the format: do all the regs. */
1089 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1090 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1093 output_register (frame
, regnum
, format
, skip_unavailable
);
1097 /* Else, list of register #s, just do listed regs. */
1098 for (i
= 1 + oind
; i
< argc
; i
++)
1100 regnum
= atoi (argv
[i
]);
1104 && gdbarch_register_name (gdbarch
, regnum
) != NULL
1105 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
1106 output_register (frame
, regnum
, format
, skip_unavailable
);
1108 error (_("bad register number"));
1112 /* Output one register REGNUM's contents in the desired FORMAT. If
1113 SKIP_UNAVAILABLE is true, skip the register if it is
1117 output_register (struct frame_info
*frame
, int regnum
, int format
,
1118 int skip_unavailable
)
1120 struct ui_out
*uiout
= current_uiout
;
1121 struct value
*val
= value_of_register (regnum
, frame
);
1122 struct value_print_options opts
;
1124 if (skip_unavailable
&& !value_entirely_available (val
))
1127 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1128 uiout
->field_int ("number", regnum
);
1138 get_formatted_print_options (&opts
, format
);
1140 val_print (value_type (val
),
1141 value_embedded_offset (val
), 0,
1142 &stb
, 0, val
, &opts
, current_language
);
1143 uiout
->field_stream ("value", stb
);
1146 /* Write given values into registers. The registers and values are
1147 given as pairs. The corresponding MI command is
1148 -data-write-register-values <format>
1149 [<regnum1> <value1>...<regnumN> <valueN>] */
1151 mi_cmd_data_write_register_values (const char *command
, char **argv
, int argc
)
1153 struct regcache
*regcache
;
1154 struct gdbarch
*gdbarch
;
1157 /* Note that the test for a valid register must include checking the
1158 gdbarch_register_name because gdbarch_num_regs may be allocated
1159 for the union of the register sets within a family of related
1160 processors. In this case, some entries of gdbarch_register_name
1161 will change depending upon the particular processor being
1164 regcache
= get_current_regcache ();
1165 gdbarch
= regcache
->arch ();
1166 numregs
= gdbarch_num_cooked_regs (gdbarch
);
1169 error (_("-data-write-register-values: Usage: -data-write-register-"
1170 "values <format> [<regnum1> <value1>...<regnumN> <valueN>]"));
1172 if (!target_has_registers
)
1173 error (_("-data-write-register-values: No registers."));
1176 error (_("-data-write-register-values: No regs and values specified."));
1179 error (_("-data-write-register-values: "
1180 "Regs and vals are not in pairs."));
1182 for (i
= 1; i
< argc
; i
= i
+ 2)
1184 int regnum
= atoi (argv
[i
]);
1186 if (regnum
>= 0 && regnum
< numregs
1187 && gdbarch_register_name (gdbarch
, regnum
)
1188 && *gdbarch_register_name (gdbarch
, regnum
))
1192 /* Get the value as a number. */
1193 value
= parse_and_eval_address (argv
[i
+ 1]);
1195 /* Write it down. */
1196 regcache_cooked_write_signed (regcache
, regnum
, value
);
1199 error (_("bad register number"));
1203 /* Evaluate the value of the argument. The argument is an
1204 expression. If the expression contains spaces it needs to be
1205 included in double quotes. */
1208 mi_cmd_data_evaluate_expression (const char *command
, char **argv
, int argc
)
1211 struct value_print_options opts
;
1212 struct ui_out
*uiout
= current_uiout
;
1215 error (_("-data-evaluate-expression: "
1216 "Usage: -data-evaluate-expression expression"));
1218 expression_up expr
= parse_expression (argv
[0]);
1220 val
= evaluate_expression (expr
.get ());
1224 /* Print the result of the expression evaluation. */
1225 get_user_print_options (&opts
);
1227 common_val_print (val
, &stb
, 0, &opts
, current_language
);
1229 uiout
->field_stream ("value", stb
);
1232 /* This is the -data-read-memory command.
1234 ADDR: start address of data to be dumped.
1235 WORD-FORMAT: a char indicating format for the ``word''. See
1237 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
1238 NR_ROW: Number of rows.
1239 NR_COL: The number of colums (words per row).
1240 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
1241 ASCHAR for unprintable characters.
1243 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
1244 displayes them. Returns:
1246 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
1249 The number of bytes read is SIZE*ROW*COL. */
1252 mi_cmd_data_read_memory (const char *command
, char **argv
, int argc
)
1254 struct gdbarch
*gdbarch
= get_current_arch ();
1255 struct ui_out
*uiout
= current_uiout
;
1257 long total_bytes
, nr_cols
, nr_rows
;
1259 struct type
*word_type
;
1271 static const struct mi_opt opts
[] =
1273 {"o", OFFSET_OPT
, 1},
1279 int opt
= mi_getopt ("-data-read-memory", argc
, argv
, opts
,
1284 switch ((enum opt
) opt
)
1287 offset
= atol (oarg
);
1294 if (argc
< 5 || argc
> 6)
1295 error (_("-data-read-memory: Usage: "
1296 "ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR]."));
1298 /* Extract all the arguments. */
1300 /* Start address of the memory dump. */
1301 addr
= parse_and_eval_address (argv
[0]) + offset
;
1302 /* The format character to use when displaying a memory word. See
1303 the ``x'' command. */
1304 word_format
= argv
[1][0];
1305 /* The size of the memory word. */
1306 word_size
= atol (argv
[2]);
1310 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1314 word_type
= builtin_type (gdbarch
)->builtin_int16
;
1318 word_type
= builtin_type (gdbarch
)->builtin_int32
;
1322 word_type
= builtin_type (gdbarch
)->builtin_int64
;
1326 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1329 /* The number of rows. */
1330 nr_rows
= atol (argv
[3]);
1332 error (_("-data-read-memory: invalid number of rows."));
1334 /* Number of bytes per row. */
1335 nr_cols
= atol (argv
[4]);
1337 error (_("-data-read-memory: invalid number of columns."));
1339 /* The un-printable character when printing ascii. */
1345 /* Create a buffer and read it in. */
1346 total_bytes
= word_size
* nr_rows
* nr_cols
;
1348 gdb::byte_vector
mbuf (total_bytes
);
1350 nr_bytes
= target_read (current_top_target (), TARGET_OBJECT_MEMORY
, NULL
,
1351 mbuf
.data (), addr
, total_bytes
);
1353 error (_("Unable to read memory."));
1355 /* Output the header information. */
1356 uiout
->field_core_addr ("addr", gdbarch
, addr
);
1357 uiout
->field_int ("nr-bytes", nr_bytes
);
1358 uiout
->field_int ("total-bytes", total_bytes
);
1359 uiout
->field_core_addr ("next-row", gdbarch
, addr
+ word_size
* nr_cols
);
1360 uiout
->field_core_addr ("prev-row", gdbarch
, addr
- word_size
* nr_cols
);
1361 uiout
->field_core_addr ("next-page", gdbarch
, addr
+ total_bytes
);
1362 uiout
->field_core_addr ("prev-page", gdbarch
, addr
- total_bytes
);
1364 /* Build the result as a two dimentional table. */
1371 ui_out_emit_list
list_emitter (uiout
, "memory");
1372 for (row
= 0, row_byte
= 0;
1374 row
++, row_byte
+= nr_cols
* word_size
)
1378 struct value_print_options print_opts
;
1380 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1381 uiout
->field_core_addr ("addr", gdbarch
, addr
+ row_byte
);
1382 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr +
1385 ui_out_emit_list
list_data_emitter (uiout
, "data");
1386 get_formatted_print_options (&print_opts
, word_format
);
1387 for (col
= 0, col_byte
= row_byte
;
1389 col
++, col_byte
+= word_size
)
1391 if (col_byte
+ word_size
> nr_bytes
)
1393 uiout
->field_string (NULL
, "N/A");
1398 print_scalar_formatted (&mbuf
[col_byte
], word_type
,
1399 &print_opts
, word_asize
, &stream
);
1400 uiout
->field_stream (NULL
, stream
);
1410 for (byte
= row_byte
;
1411 byte
< row_byte
+ word_size
* nr_cols
; byte
++)
1413 if (byte
>= nr_bytes
)
1415 else if (mbuf
[byte
] < 32 || mbuf
[byte
] > 126)
1416 stream
.putc (aschar
);
1418 stream
.putc (mbuf
[byte
]);
1420 uiout
->field_stream ("ascii", stream
);
1427 mi_cmd_data_read_memory_bytes (const char *command
, char **argv
, int argc
)
1429 struct gdbarch
*gdbarch
= get_current_arch ();
1430 struct ui_out
*uiout
= current_uiout
;
1434 int unit_size
= gdbarch_addressable_memory_unit_size (gdbarch
);
1441 static const struct mi_opt opts
[] =
1443 {"o", OFFSET_OPT
, 1},
1449 int opt
= mi_getopt ("-data-read-memory-bytes", argc
, argv
, opts
,
1453 switch ((enum opt
) opt
)
1456 offset
= atol (oarg
);
1464 error (_("Usage: [ -o OFFSET ] ADDR LENGTH."));
1466 addr
= parse_and_eval_address (argv
[0]) + offset
;
1467 length
= atol (argv
[1]);
1469 std::vector
<memory_read_result
> result
1470 = read_memory_robust (current_top_target (), addr
, length
);
1472 if (result
.size () == 0)
1473 error (_("Unable to read memory."));
1475 ui_out_emit_list
list_emitter (uiout
, "memory");
1476 for (const memory_read_result
&read_result
: result
)
1478 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1480 uiout
->field_core_addr ("begin", gdbarch
, read_result
.begin
);
1481 uiout
->field_core_addr ("offset", gdbarch
, read_result
.begin
- addr
);
1482 uiout
->field_core_addr ("end", gdbarch
, read_result
.end
);
1484 std::string data
= bin2hex (read_result
.data
.get (),
1485 (read_result
.end
- read_result
.begin
)
1487 uiout
->field_string ("contents", data
.c_str ());
1491 /* Implementation of the -data-write_memory command.
1493 COLUMN_OFFSET: optional argument. Must be preceded by '-o'. The
1494 offset from the beginning of the memory grid row where the cell to
1496 ADDR: start address of the row in the memory grid where the memory
1497 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
1498 the location to write to.
1499 FORMAT: a char indicating format for the ``word''. See
1501 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
1502 VALUE: value to be written into the memory address.
1504 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1509 mi_cmd_data_write_memory (const char *command
, char **argv
, int argc
)
1511 struct gdbarch
*gdbarch
= get_current_arch ();
1512 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1515 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1516 enough when using a compiler other than GCC. */
1525 static const struct mi_opt opts
[] =
1527 {"o", OFFSET_OPT
, 1},
1533 int opt
= mi_getopt ("-data-write-memory", argc
, argv
, opts
,
1538 switch ((enum opt
) opt
)
1541 offset
= atol (oarg
);
1549 error (_("-data-write-memory: Usage: "
1550 "[-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE."));
1552 /* Extract all the arguments. */
1553 /* Start address of the memory dump. */
1554 addr
= parse_and_eval_address (argv
[0]);
1555 /* The size of the memory word. */
1556 word_size
= atol (argv
[2]);
1558 /* Calculate the real address of the write destination. */
1559 addr
+= (offset
* word_size
);
1561 /* Get the value as a number. */
1562 value
= parse_and_eval_address (argv
[3]);
1563 /* Get the value into an array. */
1564 gdb::byte_vector
buffer (word_size
);
1565 store_signed_integer (buffer
.data (), word_size
, byte_order
, value
);
1566 /* Write it down to memory. */
1567 write_memory_with_notification (addr
, buffer
.data (), word_size
);
1570 /* Implementation of the -data-write-memory-bytes command.
1573 DATA: string of bytes to write at that address
1574 COUNT: number of bytes to be filled (decimal integer). */
1577 mi_cmd_data_write_memory_bytes (const char *command
, char **argv
, int argc
)
1581 size_t len_hex
, len_bytes
, len_units
, i
, steps
, remaining_units
;
1582 long int count_units
;
1585 if (argc
!= 2 && argc
!= 3)
1586 error (_("Usage: ADDR DATA [COUNT]."));
1588 addr
= parse_and_eval_address (argv
[0]);
1590 len_hex
= strlen (cdata
);
1591 unit_size
= gdbarch_addressable_memory_unit_size (get_current_arch ());
1593 if (len_hex
% (unit_size
* 2) != 0)
1594 error (_("Hex-encoded '%s' must represent an integral number of "
1595 "addressable memory units."),
1598 len_bytes
= len_hex
/ 2;
1599 len_units
= len_bytes
/ unit_size
;
1602 count_units
= strtoul (argv
[2], NULL
, 10);
1604 count_units
= len_units
;
1606 gdb::byte_vector
databuf (len_bytes
);
1608 for (i
= 0; i
< len_bytes
; ++i
)
1611 if (sscanf (cdata
+ i
* 2, "%02x", &x
) != 1)
1612 error (_("Invalid argument"));
1613 databuf
[i
] = (gdb_byte
) x
;
1616 gdb::byte_vector data
;
1617 if (len_units
< count_units
)
1619 /* Pattern is made of less units than count:
1620 repeat pattern to fill memory. */
1621 data
= gdb::byte_vector (count_units
* unit_size
);
1623 /* Number of times the pattern is entirely repeated. */
1624 steps
= count_units
/ len_units
;
1625 /* Number of remaining addressable memory units. */
1626 remaining_units
= count_units
% len_units
;
1627 for (i
= 0; i
< steps
; i
++)
1628 memcpy (&data
[i
* len_bytes
], &databuf
[0], len_bytes
);
1630 if (remaining_units
> 0)
1631 memcpy (&data
[steps
* len_bytes
], &databuf
[0],
1632 remaining_units
* unit_size
);
1636 /* Pattern is longer than or equal to count:
1637 just copy count addressable memory units. */
1638 data
= std::move (databuf
);
1641 write_memory_with_notification (addr
, data
.data (), count_units
);
1645 mi_cmd_enable_timings (const char *command
, char **argv
, int argc
)
1651 if (strcmp (argv
[0], "yes") == 0)
1653 else if (strcmp (argv
[0], "no") == 0)
1664 error (_("-enable-timings: Usage: %s {yes|no}"), command
);
1668 mi_cmd_list_features (const char *command
, char **argv
, int argc
)
1672 struct ui_out
*uiout
= current_uiout
;
1674 ui_out_emit_list
list_emitter (uiout
, "features");
1675 uiout
->field_string (NULL
, "frozen-varobjs");
1676 uiout
->field_string (NULL
, "pending-breakpoints");
1677 uiout
->field_string (NULL
, "thread-info");
1678 uiout
->field_string (NULL
, "data-read-memory-bytes");
1679 uiout
->field_string (NULL
, "breakpoint-notifications");
1680 uiout
->field_string (NULL
, "ada-task-info");
1681 uiout
->field_string (NULL
, "language-option");
1682 uiout
->field_string (NULL
, "info-gdb-mi-command");
1683 uiout
->field_string (NULL
, "undefined-command-error-code");
1684 uiout
->field_string (NULL
, "exec-run-start-option");
1685 uiout
->field_string (NULL
, "data-disassemble-a-option");
1687 if (ext_lang_initialized_p (get_ext_lang_defn (EXT_LANG_PYTHON
)))
1688 uiout
->field_string (NULL
, "python");
1693 error (_("-list-features should be passed no arguments"));
1697 mi_cmd_list_target_features (const char *command
, char **argv
, int argc
)
1701 struct ui_out
*uiout
= current_uiout
;
1703 ui_out_emit_list
list_emitter (uiout
, "features");
1705 uiout
->field_string (NULL
, "async");
1706 if (target_can_execute_reverse
)
1707 uiout
->field_string (NULL
, "reverse");
1711 error (_("-list-target-features should be passed no arguments"));
1715 mi_cmd_add_inferior (const char *command
, char **argv
, int argc
)
1717 struct inferior
*inf
;
1720 error (_("-add-inferior should be passed no arguments"));
1722 inf
= add_inferior_with_spaces ();
1724 current_uiout
->field_fmt ("inferior", "i%d", inf
->num
);
1727 /* Callback used to find the first inferior other than the current
1731 get_other_inferior (struct inferior
*inf
, void *arg
)
1733 if (inf
== current_inferior ())
1740 mi_cmd_remove_inferior (const char *command
, char **argv
, int argc
)
1743 struct inferior
*inf
;
1746 error (_("-remove-inferior should be passed a single argument"));
1748 if (sscanf (argv
[0], "i%d", &id
) != 1)
1749 error (_("the thread group id is syntactically invalid"));
1751 inf
= find_inferior_id (id
);
1753 error (_("the specified thread group does not exist"));
1756 error (_("cannot remove an active inferior"));
1758 if (inf
== current_inferior ())
1760 struct thread_info
*tp
= 0;
1761 struct inferior
*new_inferior
1762 = iterate_over_inferiors (get_other_inferior
, NULL
);
1764 if (new_inferior
== NULL
)
1765 error (_("Cannot remove last inferior"));
1767 set_current_inferior (new_inferior
);
1768 if (new_inferior
->pid
!= 0)
1769 tp
= any_thread_of_inferior (new_inferior
);
1771 switch_to_thread (tp
);
1773 switch_to_no_thread ();
1774 set_current_program_space (new_inferior
->pspace
);
1777 delete_inferior (inf
);
1782 /* Execute a command within a safe environment.
1783 Return <0 for error; >=0 for ok.
1785 args->action will tell mi_execute_command what action
1786 to perform after the given command has executed (display/suppress
1787 prompt, display error). */
1790 captured_mi_execute_command (struct ui_out
*uiout
, struct mi_parse
*context
)
1792 struct mi_interp
*mi
= (struct mi_interp
*) command_interp ();
1795 current_command_ts
= context
->cmd_start
;
1797 scoped_restore save_token
= make_scoped_restore (¤t_token
,
1800 running_result_record_printed
= 0;
1802 switch (context
->op
)
1805 /* A MI command was read from the input stream. */
1807 /* FIXME: gdb_???? */
1808 fprintf_unfiltered (mi
->raw_stdout
,
1809 " token=`%s' command=`%s' args=`%s'\n",
1810 context
->token
, context
->command
, context
->args
);
1812 mi_cmd_execute (context
);
1814 /* Print the result if there were no errors.
1816 Remember that on the way out of executing a command, you have
1817 to directly use the mi_interp's uiout, since the command
1818 could have reset the interpreter, in which case the current
1819 uiout will most likely crash in the mi_out_* routines. */
1820 if (!running_result_record_printed
)
1822 fputs_unfiltered (context
->token
, mi
->raw_stdout
);
1823 /* There's no particularly good reason why target-connect results
1824 in not ^done. Should kill ^connected for MI3. */
1825 fputs_unfiltered (strcmp (context
->command
, "target-select") == 0
1826 ? "^connected" : "^done", mi
->raw_stdout
);
1827 mi_out_put (uiout
, mi
->raw_stdout
);
1828 mi_out_rewind (uiout
);
1829 mi_print_timing_maybe (mi
->raw_stdout
);
1830 fputs_unfiltered ("\n", mi
->raw_stdout
);
1833 /* The command does not want anything to be printed. In that
1834 case, the command probably should not have written anything
1835 to uiout, but in case it has written something, discard it. */
1836 mi_out_rewind (uiout
);
1843 /* A CLI command was read from the input stream. */
1844 /* This "feature" will be removed as soon as we have a
1845 complete set of mi commands. */
1846 /* Echo the command on the console. */
1847 fprintf_unfiltered (gdb_stdlog
, "%s\n", context
->command
);
1848 /* Call the "console" interpreter. */
1849 argv
[0] = (char *) INTERP_CONSOLE
;
1850 argv
[1] = context
->command
;
1851 mi_cmd_interpreter_exec ("-interpreter-exec", argv
, 2);
1853 /* If we changed interpreters, DON'T print out anything. */
1854 if (current_interp_named_p (INTERP_MI
)
1855 || current_interp_named_p (INTERP_MI1
)
1856 || current_interp_named_p (INTERP_MI2
)
1857 || current_interp_named_p (INTERP_MI3
))
1859 if (!running_result_record_printed
)
1861 fputs_unfiltered (context
->token
, mi
->raw_stdout
);
1862 fputs_unfiltered ("^done", mi
->raw_stdout
);
1863 mi_out_put (uiout
, mi
->raw_stdout
);
1864 mi_out_rewind (uiout
);
1865 mi_print_timing_maybe (mi
->raw_stdout
);
1866 fputs_unfiltered ("\n", mi
->raw_stdout
);
1869 mi_out_rewind (uiout
);
1876 /* Print a gdb exception to the MI output stream. */
1879 mi_print_exception (const char *token
, struct gdb_exception exception
)
1881 struct mi_interp
*mi
= (struct mi_interp
*) current_interpreter ();
1883 fputs_unfiltered (token
, mi
->raw_stdout
);
1884 fputs_unfiltered ("^error,msg=\"", mi
->raw_stdout
);
1885 if (exception
.message
== NULL
)
1886 fputs_unfiltered ("unknown error", mi
->raw_stdout
);
1888 fputstr_unfiltered (exception
.message
, '"', mi
->raw_stdout
);
1889 fputs_unfiltered ("\"", mi
->raw_stdout
);
1891 switch (exception
.error
)
1893 case UNDEFINED_COMMAND_ERROR
:
1894 fputs_unfiltered (",code=\"undefined-command\"", mi
->raw_stdout
);
1898 fputs_unfiltered ("\n", mi
->raw_stdout
);
1901 /* Determine whether the parsed command already notifies the
1902 user_selected_context_changed observer. */
1905 command_notifies_uscc_observer (struct mi_parse
*command
)
1907 if (command
->op
== CLI_COMMAND
)
1909 /* CLI commands "thread" and "inferior" already send it. */
1910 return (strncmp (command
->command
, "thread ", 7) == 0
1911 || strncmp (command
->command
, "inferior ", 9) == 0);
1913 else /* MI_COMMAND */
1915 if (strcmp (command
->command
, "interpreter-exec") == 0
1916 && command
->argc
> 1)
1918 /* "thread" and "inferior" again, but through -interpreter-exec. */
1919 return (strncmp (command
->argv
[1], "thread ", 7) == 0
1920 || strncmp (command
->argv
[1], "inferior ", 9) == 0);
1924 /* -thread-select already sends it. */
1925 return strcmp (command
->command
, "thread-select") == 0;
1930 mi_execute_command (const char *cmd
, int from_tty
)
1933 std::unique_ptr
<struct mi_parse
> command
;
1935 /* This is to handle EOF (^D). We just quit gdb. */
1936 /* FIXME: we should call some API function here. */
1938 quit_force (NULL
, from_tty
);
1940 target_log_command (cmd
);
1944 command
= mi_parse (cmd
, &token
);
1946 CATCH (exception
, RETURN_MASK_ALL
)
1948 mi_print_exception (token
, exception
);
1953 if (command
!= NULL
)
1955 ptid_t previous_ptid
= inferior_ptid
;
1957 gdb::optional
<scoped_restore_tmpl
<int>> restore_suppress
;
1959 if (command
->cmd
!= NULL
&& command
->cmd
->suppress_notification
!= NULL
)
1960 restore_suppress
.emplace (command
->cmd
->suppress_notification
, 1);
1962 command
->token
= token
;
1966 command
->cmd_start
= new mi_timestamp ();
1967 timestamp (command
->cmd_start
);
1972 captured_mi_execute_command (current_uiout
, command
.get ());
1974 CATCH (result
, RETURN_MASK_ALL
)
1976 /* Like in start_event_loop, enable input and force display
1977 of the prompt. Otherwise, any command that calls
1978 async_disable_stdin, and then throws, will leave input
1980 async_enable_stdin ();
1981 current_ui
->prompt_state
= PROMPT_NEEDED
;
1983 /* The command execution failed and error() was called
1985 mi_print_exception (command
->token
, result
);
1986 mi_out_rewind (current_uiout
);
1990 bpstat_do_actions ();
1992 if (/* The notifications are only output when the top-level
1993 interpreter (specified on the command line) is MI. */
1994 top_level_interpreter ()->interp_ui_out ()->is_mi_like_p ()
1995 /* Don't try report anything if there are no threads --
1996 the program is dead. */
1998 /* If the command already reports the thread change, no need to do it
2000 && !command_notifies_uscc_observer (command
.get ()))
2002 int report_change
= 0;
2004 if (command
->thread
== -1)
2006 report_change
= (previous_ptid
!= null_ptid
2007 && inferior_ptid
!= previous_ptid
2008 && inferior_ptid
!= null_ptid
);
2010 else if (inferior_ptid
!= null_ptid
)
2012 struct thread_info
*ti
= inferior_thread ();
2014 report_change
= (ti
->global_num
!= command
->thread
);
2019 gdb::observers::user_selected_context_changed
.notify
2020 (USER_SELECTED_THREAD
| USER_SELECTED_FRAME
);
2027 mi_cmd_execute (struct mi_parse
*parse
)
2029 scoped_value_mark cleanup
= prepare_execute_command ();
2031 if (parse
->all
&& parse
->thread_group
!= -1)
2032 error (_("Cannot specify --thread-group together with --all"));
2034 if (parse
->all
&& parse
->thread
!= -1)
2035 error (_("Cannot specify --thread together with --all"));
2037 if (parse
->thread_group
!= -1 && parse
->thread
!= -1)
2038 error (_("Cannot specify --thread together with --thread-group"));
2040 if (parse
->frame
!= -1 && parse
->thread
== -1)
2041 error (_("Cannot specify --frame without --thread"));
2043 if (parse
->thread_group
!= -1)
2045 struct inferior
*inf
= find_inferior_id (parse
->thread_group
);
2046 struct thread_info
*tp
= 0;
2049 error (_("Invalid thread group for the --thread-group option"));
2051 set_current_inferior (inf
);
2052 /* This behaviour means that if --thread-group option identifies
2053 an inferior with multiple threads, then a random one will be
2054 picked. This is not a problem -- frontend should always
2055 provide --thread if it wishes to operate on a specific
2058 tp
= any_live_thread_of_inferior (inf
);
2060 switch_to_thread (tp
);
2062 switch_to_no_thread ();
2063 set_current_program_space (inf
->pspace
);
2066 if (parse
->thread
!= -1)
2068 thread_info
*tp
= find_thread_global_id (parse
->thread
);
2071 error (_("Invalid thread id: %d"), parse
->thread
);
2073 if (tp
->state
== THREAD_EXITED
)
2074 error (_("Thread id: %d has terminated"), parse
->thread
);
2076 switch_to_thread (tp
);
2079 if (parse
->frame
!= -1)
2081 struct frame_info
*fid
;
2082 int frame
= parse
->frame
;
2084 fid
= find_relative_frame (get_current_frame (), &frame
);
2086 /* find_relative_frame was successful */
2089 error (_("Invalid frame id: %d"), frame
);
2092 gdb::optional
<scoped_restore_current_language
> lang_saver
;
2093 if (parse
->language
!= language_unknown
)
2095 lang_saver
.emplace ();
2096 set_language (parse
->language
);
2099 current_context
= parse
;
2101 if (parse
->cmd
->argv_func
!= NULL
)
2103 parse
->cmd
->argv_func (parse
->command
, parse
->argv
, parse
->argc
);
2105 else if (parse
->cmd
->cli
.cmd
!= 0)
2107 /* FIXME: DELETE THIS. */
2108 /* The operation is still implemented by a cli command. */
2109 /* Must be a synchronous one. */
2110 mi_execute_cli_command (parse
->cmd
->cli
.cmd
, parse
->cmd
->cli
.args_p
,
2115 /* FIXME: DELETE THIS. */
2118 stb
.puts ("Undefined mi command: ");
2119 stb
.putstr (parse
->command
, '"');
2120 stb
.puts (" (missing implementation)");
2126 /* FIXME: This is just a hack so we can get some extra commands going.
2127 We don't want to channel things through the CLI, but call libgdb directly.
2128 Use only for synchronous commands. */
2131 mi_execute_cli_command (const char *cmd
, int args_p
, const char *args
)
2135 std::string run
= cmd
;
2138 run
= run
+ " " + args
;
2140 /* FIXME: gdb_???? */
2141 fprintf_unfiltered (gdb_stdout
, "cli=%s run=%s\n",
2143 execute_command (run
.c_str (), 0 /* from_tty */ );
2148 mi_execute_async_cli_command (const char *cli_command
, char **argv
, int argc
)
2150 std::string run
= cli_command
;
2153 run
= run
+ " " + *argv
;
2157 execute_command (run
.c_str (), 0 /* from_tty */ );
2161 mi_load_progress (const char *section_name
,
2162 unsigned long sent_so_far
,
2163 unsigned long total_section
,
2164 unsigned long total_sent
,
2165 unsigned long grand_total
)
2167 using namespace std::chrono
;
2168 static steady_clock::time_point last_update
;
2169 static char *previous_sect_name
= NULL
;
2171 struct mi_interp
*mi
= (struct mi_interp
*) current_interpreter ();
2173 /* This function is called through deprecated_show_load_progress
2174 which means uiout may not be correct. Fix it for the duration
2175 of this function. */
2177 std::unique_ptr
<ui_out
> uiout
;
2179 if (current_interp_named_p (INTERP_MI
)
2180 || current_interp_named_p (INTERP_MI2
))
2181 uiout
.reset (mi_out_new (2));
2182 else if (current_interp_named_p (INTERP_MI1
))
2183 uiout
.reset (mi_out_new (1));
2184 else if (current_interp_named_p (INTERP_MI3
))
2185 uiout
.reset (mi_out_new (3));
2189 scoped_restore save_uiout
2190 = make_scoped_restore (¤t_uiout
, uiout
.get ());
2192 new_section
= (previous_sect_name
?
2193 strcmp (previous_sect_name
, section_name
) : 1);
2196 xfree (previous_sect_name
);
2197 previous_sect_name
= xstrdup (section_name
);
2200 fputs_unfiltered (current_token
, mi
->raw_stdout
);
2201 fputs_unfiltered ("+download", mi
->raw_stdout
);
2203 ui_out_emit_tuple
tuple_emitter (uiout
.get (), NULL
);
2204 uiout
->field_string ("section", section_name
);
2205 uiout
->field_int ("section-size", total_section
);
2206 uiout
->field_int ("total-size", grand_total
);
2208 mi_out_put (uiout
.get (), mi
->raw_stdout
);
2209 fputs_unfiltered ("\n", mi
->raw_stdout
);
2210 gdb_flush (mi
->raw_stdout
);
2213 steady_clock::time_point time_now
= steady_clock::now ();
2214 if (time_now
- last_update
> milliseconds (500))
2216 last_update
= time_now
;
2218 fputs_unfiltered (current_token
, mi
->raw_stdout
);
2219 fputs_unfiltered ("+download", mi
->raw_stdout
);
2221 ui_out_emit_tuple
tuple_emitter (uiout
.get (), NULL
);
2222 uiout
->field_string ("section", section_name
);
2223 uiout
->field_int ("section-sent", sent_so_far
);
2224 uiout
->field_int ("section-size", total_section
);
2225 uiout
->field_int ("total-sent", total_sent
);
2226 uiout
->field_int ("total-size", grand_total
);
2228 mi_out_put (uiout
.get (), mi
->raw_stdout
);
2229 fputs_unfiltered ("\n", mi
->raw_stdout
);
2230 gdb_flush (mi
->raw_stdout
);
2235 timestamp (struct mi_timestamp
*tv
)
2237 using namespace std::chrono
;
2239 tv
->wallclock
= steady_clock::now ();
2240 run_time_clock::now (tv
->utime
, tv
->stime
);
2244 print_diff_now (struct ui_file
*file
, struct mi_timestamp
*start
)
2246 struct mi_timestamp now
;
2249 print_diff (file
, start
, &now
);
2253 mi_print_timing_maybe (struct ui_file
*file
)
2255 /* If the command is -enable-timing then do_timings may be true
2256 whilst current_command_ts is not initialized. */
2257 if (do_timings
&& current_command_ts
)
2258 print_diff_now (file
, current_command_ts
);
2262 print_diff (struct ui_file
*file
, struct mi_timestamp
*start
,
2263 struct mi_timestamp
*end
)
2265 using namespace std::chrono
;
2267 duration
<double> wallclock
= end
->wallclock
- start
->wallclock
;
2268 duration
<double> utime
= end
->utime
- start
->utime
;
2269 duration
<double> stime
= end
->stime
- start
->stime
;
2273 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
2274 wallclock
.count (), utime
.count (), stime
.count ());
2278 mi_cmd_trace_define_variable (const char *command
, char **argv
, int argc
)
2280 LONGEST initval
= 0;
2281 struct trace_state_variable
*tsv
;
2284 if (argc
!= 1 && argc
!= 2)
2285 error (_("Usage: -trace-define-variable VARIABLE [VALUE]"));
2289 error (_("Name of trace variable should start with '$'"));
2291 validate_trace_state_variable_name (name
);
2293 tsv
= find_trace_state_variable (name
);
2295 tsv
= create_trace_state_variable (name
);
2298 initval
= value_as_long (parse_and_eval (argv
[1]));
2300 tsv
->initial_value
= initval
;
2304 mi_cmd_trace_list_variables (const char *command
, char **argv
, int argc
)
2307 error (_("-trace-list-variables: no arguments allowed"));
2309 tvariables_info_1 ();
2313 mi_cmd_trace_find (const char *command
, char **argv
, int argc
)
2318 error (_("trace selection mode is required"));
2322 if (strcmp (mode
, "none") == 0)
2324 tfind_1 (tfind_number
, -1, 0, 0, 0);
2328 check_trace_running (current_trace_status ());
2330 if (strcmp (mode
, "frame-number") == 0)
2333 error (_("frame number is required"));
2334 tfind_1 (tfind_number
, atoi (argv
[1]), 0, 0, 0);
2336 else if (strcmp (mode
, "tracepoint-number") == 0)
2339 error (_("tracepoint number is required"));
2340 tfind_1 (tfind_tp
, atoi (argv
[1]), 0, 0, 0);
2342 else if (strcmp (mode
, "pc") == 0)
2345 error (_("PC is required"));
2346 tfind_1 (tfind_pc
, 0, parse_and_eval_address (argv
[1]), 0, 0);
2348 else if (strcmp (mode
, "pc-inside-range") == 0)
2351 error (_("Start and end PC are required"));
2352 tfind_1 (tfind_range
, 0, parse_and_eval_address (argv
[1]),
2353 parse_and_eval_address (argv
[2]), 0);
2355 else if (strcmp (mode
, "pc-outside-range") == 0)
2358 error (_("Start and end PC are required"));
2359 tfind_1 (tfind_outside
, 0, parse_and_eval_address (argv
[1]),
2360 parse_and_eval_address (argv
[2]), 0);
2362 else if (strcmp (mode
, "line") == 0)
2365 error (_("Line is required"));
2367 std::vector
<symtab_and_line
> sals
2368 = decode_line_with_current_source (argv
[1],
2369 DECODE_LINE_FUNFIRSTLINE
);
2370 const symtab_and_line
&sal
= sals
[0];
2372 if (sal
.symtab
== 0)
2373 error (_("Could not find the specified line"));
2375 CORE_ADDR start_pc
, end_pc
;
2376 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2377 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, 0);
2379 error (_("Could not find the specified line"));
2382 error (_("Invalid mode '%s'"), mode
);
2384 if (has_stack_frames () || get_traceframe_number () >= 0)
2385 print_stack_frame (get_selected_frame (NULL
), 1, LOC_AND_ADDRESS
, 1);
2389 mi_cmd_trace_save (const char *command
, char **argv
, int argc
)
2391 int target_saves
= 0;
2392 int generate_ctf
= 0;
2399 TARGET_SAVE_OPT
, CTF_OPT
2401 static const struct mi_opt opts
[] =
2403 {"r", TARGET_SAVE_OPT
, 0},
2404 {"ctf", CTF_OPT
, 0},
2410 int opt
= mi_getopt ("-trace-save", argc
, argv
, opts
,
2415 switch ((enum opt
) opt
)
2417 case TARGET_SAVE_OPT
:
2426 if (argc
- oind
!= 1)
2427 error (_("Exactly one argument required "
2428 "(file in which to save trace data)"));
2430 filename
= argv
[oind
];
2433 trace_save_ctf (filename
, target_saves
);
2435 trace_save_tfile (filename
, target_saves
);
2439 mi_cmd_trace_start (const char *command
, char **argv
, int argc
)
2441 start_tracing (NULL
);
2445 mi_cmd_trace_status (const char *command
, char **argv
, int argc
)
2447 trace_status_mi (0);
2451 mi_cmd_trace_stop (const char *command
, char **argv
, int argc
)
2453 stop_tracing (NULL
);
2454 trace_status_mi (1);
2457 /* Implement the "-ada-task-info" command. */
2460 mi_cmd_ada_task_info (const char *command
, char **argv
, int argc
)
2462 if (argc
!= 0 && argc
!= 1)
2463 error (_("Invalid MI command"));
2465 print_ada_task_info (current_uiout
, argv
[0], current_inferior ());
2468 /* Print EXPRESSION according to VALUES. */
2471 print_variable_or_computed (const char *expression
, enum print_values values
)
2475 struct ui_out
*uiout
= current_uiout
;
2479 expression_up expr
= parse_expression (expression
);
2481 if (values
== PRINT_SIMPLE_VALUES
)
2482 val
= evaluate_type (expr
.get ());
2484 val
= evaluate_expression (expr
.get ());
2486 gdb::optional
<ui_out_emit_tuple
> tuple_emitter
;
2487 if (values
!= PRINT_NO_VALUES
)
2488 tuple_emitter
.emplace (uiout
, nullptr);
2489 uiout
->field_string ("name", expression
);
2493 case PRINT_SIMPLE_VALUES
:
2494 type
= check_typedef (value_type (val
));
2495 type_print (value_type (val
), "", &stb
, -1);
2496 uiout
->field_stream ("type", stb
);
2497 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
2498 && TYPE_CODE (type
) != TYPE_CODE_STRUCT
2499 && TYPE_CODE (type
) != TYPE_CODE_UNION
)
2501 struct value_print_options opts
;
2503 get_no_prettyformat_print_options (&opts
);
2505 common_val_print (val
, &stb
, 0, &opts
, current_language
);
2506 uiout
->field_stream ("value", stb
);
2509 case PRINT_ALL_VALUES
:
2511 struct value_print_options opts
;
2513 get_no_prettyformat_print_options (&opts
);
2515 common_val_print (val
, &stb
, 0, &opts
, current_language
);
2516 uiout
->field_stream ("value", stb
);
2522 /* Implement the "-trace-frame-collected" command. */
2525 mi_cmd_trace_frame_collected (const char *command
, char **argv
, int argc
)
2527 struct bp_location
*tloc
;
2529 struct collection_list
*clist
;
2530 struct collection_list tracepoint_list
, stepping_list
;
2531 struct traceframe_info
*tinfo
;
2533 enum print_values var_print_values
= PRINT_ALL_VALUES
;
2534 enum print_values comp_print_values
= PRINT_ALL_VALUES
;
2535 int registers_format
= 'x';
2536 int memory_contents
= 0;
2537 struct ui_out
*uiout
= current_uiout
;
2545 static const struct mi_opt opts
[] =
2547 {"-var-print-values", VAR_PRINT_VALUES
, 1},
2548 {"-comp-print-values", COMP_PRINT_VALUES
, 1},
2549 {"-registers-format", REGISTERS_FORMAT
, 1},
2550 {"-memory-contents", MEMORY_CONTENTS
, 0},
2557 int opt
= mi_getopt ("-trace-frame-collected", argc
, argv
, opts
,
2561 switch ((enum opt
) opt
)
2563 case VAR_PRINT_VALUES
:
2564 var_print_values
= mi_parse_print_values (oarg
);
2566 case COMP_PRINT_VALUES
:
2567 comp_print_values
= mi_parse_print_values (oarg
);
2569 case REGISTERS_FORMAT
:
2570 registers_format
= oarg
[0];
2572 case MEMORY_CONTENTS
:
2573 memory_contents
= 1;
2579 error (_("Usage: -trace-frame-collected "
2580 "[--var-print-values PRINT_VALUES] "
2581 "[--comp-print-values PRINT_VALUES] "
2582 "[--registers-format FORMAT]"
2583 "[--memory-contents]"));
2585 /* This throws an error is not inspecting a trace frame. */
2586 tloc
= get_traceframe_location (&stepping_frame
);
2588 /* This command only makes sense for the current frame, not the
2590 scoped_restore_current_thread restore_thread
;
2591 select_frame (get_current_frame ());
2593 encode_actions (tloc
, &tracepoint_list
, &stepping_list
);
2596 clist
= &stepping_list
;
2598 clist
= &tracepoint_list
;
2600 tinfo
= get_traceframe_info ();
2602 /* Explicitly wholly collected variables. */
2604 ui_out_emit_list
list_emitter (uiout
, "explicit-variables");
2605 const std::vector
<std::string
> &wholly_collected
2606 = clist
->wholly_collected ();
2607 for (size_t i
= 0; i
< wholly_collected
.size (); i
++)
2609 const std::string
&str
= wholly_collected
[i
];
2610 print_variable_or_computed (str
.c_str (), var_print_values
);
2614 /* Computed expressions. */
2616 ui_out_emit_list
list_emitter (uiout
, "computed-expressions");
2618 const std::vector
<std::string
> &computed
= clist
->computed ();
2619 for (size_t i
= 0; i
< computed
.size (); i
++)
2621 const std::string
&str
= computed
[i
];
2622 print_variable_or_computed (str
.c_str (), comp_print_values
);
2626 /* Registers. Given pseudo-registers, and that some architectures
2627 (like MIPS) actually hide the raw registers, we don't go through
2628 the trace frame info, but instead consult the register cache for
2629 register availability. */
2631 struct frame_info
*frame
;
2632 struct gdbarch
*gdbarch
;
2636 ui_out_emit_list
list_emitter (uiout
, "registers");
2638 frame
= get_selected_frame (NULL
);
2639 gdbarch
= get_frame_arch (frame
);
2640 numregs
= gdbarch_num_cooked_regs (gdbarch
);
2642 for (regnum
= 0; regnum
< numregs
; regnum
++)
2644 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
2645 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
2648 output_register (frame
, regnum
, registers_format
, 1);
2652 /* Trace state variables. */
2654 ui_out_emit_list
list_emitter (uiout
, "tvars");
2656 for (int tvar
: tinfo
->tvars
)
2658 struct trace_state_variable
*tsv
;
2660 tsv
= find_trace_state_variable_by_number (tvar
);
2662 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
2666 uiout
->field_fmt ("name", "$%s", tsv
->name
.c_str ());
2668 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
2670 uiout
->field_int ("current", tsv
->value
);
2674 uiout
->field_skip ("name");
2675 uiout
->field_skip ("current");
2682 std::vector
<mem_range
> available_memory
;
2684 traceframe_available_memory (&available_memory
, 0, ULONGEST_MAX
);
2686 ui_out_emit_list
list_emitter (uiout
, "memory");
2688 for (const mem_range
&r
: available_memory
)
2690 struct gdbarch
*gdbarch
= target_gdbarch ();
2692 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
2694 uiout
->field_core_addr ("address", gdbarch
, r
.start
);
2695 uiout
->field_int ("length", r
.length
);
2697 gdb::byte_vector
data (r
.length
);
2699 if (memory_contents
)
2701 if (target_read_memory (r
.start
, data
.data (), r
.length
) == 0)
2703 std::string data_str
= bin2hex (data
.data (), r
.length
);
2704 uiout
->field_string ("contents", data_str
.c_str ());
2707 uiout
->field_skip ("contents");
2714 _initialize_mi_main (void)
2716 struct cmd_list_element
*c
;
2718 add_setshow_boolean_cmd ("mi-async", class_run
,
2720 Set whether MI asynchronous mode is enabled."), _("\
2721 Show whether MI asynchronous mode is enabled."), _("\
2722 Tells GDB whether MI should be in asynchronous mode."),
2723 set_mi_async_command
,
2724 show_mi_async_command
,
2728 /* Alias old "target-async" to "mi-async". */
2729 c
= add_alias_cmd ("target-async", "mi-async", class_run
, 0, &setlist
);
2730 deprecate_cmd (c
, "set mi-async");
2731 c
= add_alias_cmd ("target-async", "mi-async", class_run
, 0, &showlist
);
2732 deprecate_cmd (c
, "show mi-async");