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(). */
43 #include "mi-common.h"
48 #include "common/gdb_splay_tree.h"
49 #include "tracepoint.h"
53 #include "extension.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 int register_changed_p (int regnum
, struct 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 (!is_stopped (thread
->ptid
))
249 if (pid
!= 0 && ptid_get_pid (thread
->ptid
) != pid
)
252 switch_to_thread (thread
->ptid
);
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 (¤t_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 (!is_running (thread
->ptid
))
351 if (ptid_get_pid (thread
->ptid
) != 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
->to_can_async_p (run_target
);
412 if (inf
->pid
!= ptid_get_pid (inferior_ptid
))
414 struct thread_info
*tp
;
416 tp
= any_thread_of_process (inf
->pid
);
418 error (_("Inferior has no threads."));
420 switch_to_thread (tp
->ptid
);
425 set_current_inferior (inf
);
426 switch_to_thread (null_ptid
);
427 set_current_program_space (inf
->pspace
);
429 mi_execute_cli_command (run_cmd
, async_p
,
430 async_p
? "&" : NULL
);
435 mi_cmd_exec_run (const char *command
, char **argv
, int argc
)
439 /* Parse the command options. */
444 static const struct mi_opt opts
[] =
446 {"-start", START_OPT
, 0},
455 int opt
= mi_getopt ("-exec-run", argc
, argv
, opts
, &oind
, &oarg
);
459 switch ((enum opt
) opt
)
467 /* This command does not accept any argument. Make sure the user
468 did not provide any. */
470 error (_("Invalid argument: %s"), argv
[oind
]);
472 if (current_context
->all
)
474 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
476 iterate_over_inferiors (run_one_inferior
, &start_p
);
480 const char *run_cmd
= start_p
? "start" : "run";
481 struct target_ops
*run_target
= find_run_target ();
482 int async_p
= mi_async
&& run_target
->to_can_async_p (run_target
);
484 mi_execute_cli_command (run_cmd
, async_p
,
485 async_p
? "&" : NULL
);
491 find_thread_of_process (struct thread_info
*ti
, void *p
)
495 if (ptid_get_pid (ti
->ptid
) == pid
&& !is_exited (ti
->ptid
))
502 mi_cmd_target_detach (const char *command
, char **argv
, int argc
)
504 if (argc
!= 0 && argc
!= 1)
505 error (_("Usage: -target-detach [pid | thread-group]"));
509 struct thread_info
*tp
;
513 /* First see if we are dealing with a thread-group id. */
516 struct inferior
*inf
;
517 int id
= strtoul (argv
[0] + 1, &end
, 0);
520 error (_("Invalid syntax of thread-group id '%s'"), argv
[0]);
522 inf
= find_inferior_id (id
);
524 error (_("Non-existent thread-group id '%d'"), id
);
530 /* We must be dealing with a pid. */
531 pid
= strtol (argv
[0], &end
, 10);
534 error (_("Invalid identifier '%s'"), argv
[0]);
537 /* Pick any thread in the desired process. Current
538 target_detach detaches from the parent of inferior_ptid. */
539 tp
= iterate_over_threads (find_thread_of_process
, &pid
);
541 error (_("Thread group is empty"));
543 switch_to_thread (tp
->ptid
);
546 detach_command (NULL
, 0);
550 mi_cmd_target_flash_erase (const char *command
, char **argv
, int argc
)
552 flash_erase_command (NULL
, 0);
556 mi_cmd_thread_select (const char *command
, char **argv
, int argc
)
559 error (_("-thread-select: USAGE: threadnum."));
561 int num
= value_as_long (parse_and_eval (argv
[0]));
562 thread_info
*thr
= find_thread_global_id (num
);
564 error (_("Thread ID %d not known."), num
);
566 ptid_t previous_ptid
= inferior_ptid
;
568 thread_select (argv
[0], thr
);
570 print_selected_thread_frame (current_uiout
,
571 USER_SELECTED_THREAD
| USER_SELECTED_FRAME
);
573 /* Notify if the thread has effectively changed. */
574 if (!ptid_equal (inferior_ptid
, previous_ptid
))
576 observer_notify_user_selected_context_changed (USER_SELECTED_THREAD
577 | USER_SELECTED_FRAME
);
582 mi_cmd_thread_list_ids (const char *command
, char **argv
, int argc
)
585 error (_("-thread-list-ids: No arguments required."));
588 int current_thread
= -1;
590 update_thread_list ();
593 ui_out_emit_tuple
tuple_emitter (current_uiout
, "thread-ids");
595 struct thread_info
*tp
;
596 ALL_NON_EXITED_THREADS (tp
)
598 if (tp
->ptid
== inferior_ptid
)
599 current_thread
= tp
->global_num
;
602 current_uiout
->field_int ("thread-id", tp
->global_num
);
606 if (current_thread
!= -1)
607 current_uiout
->field_int ("current-thread-id", current_thread
);
608 current_uiout
->field_int ("number-of-threads", num
);
612 mi_cmd_thread_info (const char *command
, char **argv
, int argc
)
614 if (argc
!= 0 && argc
!= 1)
615 error (_("Invalid MI command"));
617 print_thread_info (current_uiout
, argv
[0], -1);
620 struct collect_cores_data
627 collect_cores (struct thread_info
*ti
, void *xdata
)
629 struct collect_cores_data
*data
= (struct collect_cores_data
*) xdata
;
631 if (ptid_get_pid (ti
->ptid
) == data
->pid
)
633 int core
= target_core_of_thread (ti
->ptid
);
636 data
->cores
.insert (core
);
642 struct print_one_inferior_data
645 const std::set
<int> *inferiors
;
649 print_one_inferior (struct inferior
*inferior
, void *xdata
)
651 struct print_one_inferior_data
*top_data
652 = (struct print_one_inferior_data
*) xdata
;
653 struct ui_out
*uiout
= current_uiout
;
655 if (top_data
->inferiors
->empty ()
656 || (top_data
->inferiors
->find (inferior
->pid
)
657 != top_data
->inferiors
->end ()))
659 struct collect_cores_data data
;
660 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
662 uiout
->field_fmt ("id", "i%d", inferior
->num
);
663 uiout
->field_string ("type", "process");
664 if (inferior
->has_exit_code
)
665 uiout
->field_string ("exit-code",
666 int_string (inferior
->exit_code
, 8, 0, 0, 1));
667 if (inferior
->pid
!= 0)
668 uiout
->field_int ("pid", inferior
->pid
);
670 if (inferior
->pspace
->pspace_exec_filename
!= NULL
)
672 uiout
->field_string ("executable",
673 inferior
->pspace
->pspace_exec_filename
);
676 if (inferior
->pid
!= 0)
678 data
.pid
= inferior
->pid
;
679 iterate_over_threads (collect_cores
, &data
);
682 if (!data
.cores
.empty ())
684 ui_out_emit_list
list_emitter (uiout
, "cores");
686 for (int b
: data
.cores
)
687 uiout
->field_int (NULL
, b
);
690 if (top_data
->recurse
)
691 print_thread_info (uiout
, NULL
, inferior
->pid
);
697 /* Output a field named 'cores' with a list as the value. The
698 elements of the list are obtained by splitting 'cores' on
702 output_cores (struct ui_out
*uiout
, const char *field_name
, const char *xcores
)
704 ui_out_emit_list
list_emitter (uiout
, field_name
);
705 gdb::unique_xmalloc_ptr
<char> cores (xstrdup (xcores
));
706 char *p
= cores
.get ();
708 for (p
= strtok (p
, ","); p
; p
= strtok (NULL
, ","))
709 uiout
->field_string (NULL
, p
);
713 list_available_thread_groups (const std::set
<int> &ids
, int recurse
)
715 struct ui_out
*uiout
= current_uiout
;
717 /* This keeps a map from integer (pid) to vector of struct osdata_item.
718 The vector contains information about all threads for the given pid. */
719 std::map
<int, std::vector
<osdata_item
>> tree
;
721 /* get_osdata will throw if it cannot return data. */
722 std::unique_ptr
<osdata
> data
= get_osdata ("processes");
726 std::unique_ptr
<osdata
> threads
= get_osdata ("threads");
728 for (const osdata_item
&item
: threads
->items
)
730 const std::string
*pid
= get_osdata_column (item
, "pid");
731 int pid_i
= strtoul (pid
->c_str (), NULL
, 0);
733 tree
[pid_i
].push_back (item
);
737 ui_out_emit_list
list_emitter (uiout
, "groups");
739 for (const osdata_item
&item
: data
->items
)
741 const std::string
*pid
= get_osdata_column (item
, "pid");
742 const std::string
*cmd
= get_osdata_column (item
, "command");
743 const std::string
*user
= get_osdata_column (item
, "user");
744 const std::string
*cores
= get_osdata_column (item
, "cores");
746 int pid_i
= strtoul (pid
->c_str (), NULL
, 0);
748 /* At present, the target will return all available processes
749 and if information about specific ones was required, we filter
750 undesired processes here. */
751 if (!ids
.empty () && ids
.find (pid_i
) == ids
.end ())
754 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
756 uiout
->field_fmt ("id", "%s", pid
->c_str ());
757 uiout
->field_string ("type", "process");
759 uiout
->field_string ("description", cmd
->c_str ());
761 uiout
->field_string ("user", user
->c_str ());
763 output_cores (uiout
, "cores", cores
->c_str ());
767 auto n
= tree
.find (pid_i
);
768 if (n
!= tree
.end ())
770 std::vector
<osdata_item
> &children
= n
->second
;
772 ui_out_emit_list
thread_list_emitter (uiout
, "threads");
774 for (const osdata_item
&child
: children
)
776 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
777 const std::string
*tid
= get_osdata_column (child
, "tid");
778 const std::string
*tcore
= get_osdata_column (child
, "core");
780 uiout
->field_string ("id", tid
->c_str ());
782 uiout
->field_string ("core", tcore
->c_str ());
790 mi_cmd_list_thread_groups (const char *command
, char **argv
, int argc
)
792 struct ui_out
*uiout
= current_uiout
;
799 AVAILABLE_OPT
, RECURSE_OPT
801 static const struct mi_opt opts
[] =
803 {"-available", AVAILABLE_OPT
, 0},
804 {"-recurse", RECURSE_OPT
, 1},
813 int opt
= mi_getopt ("-list-thread-groups", argc
, argv
, opts
,
818 switch ((enum opt
) opt
)
824 if (strcmp (oarg
, "0") == 0)
826 else if (strcmp (oarg
, "1") == 0)
829 error (_("only '0' and '1' are valid values "
830 "for the '--recurse' option"));
835 for (; oind
< argc
; ++oind
)
840 if (*(argv
[oind
]) != 'i')
841 error (_("invalid syntax of group id '%s'"), argv
[oind
]);
843 inf
= strtoul (argv
[oind
] + 1, &end
, 0);
846 error (_("invalid syntax of group id '%s'"), argv
[oind
]);
852 list_available_thread_groups (ids
, recurse
);
854 else if (ids
.size () == 1)
856 /* Local thread groups, single id. */
857 int id
= *(ids
.begin ());
858 struct inferior
*inf
= find_inferior_id (id
);
861 error (_("Non-existent thread group id '%d'"), id
);
863 print_thread_info (uiout
, NULL
, inf
->pid
);
867 struct print_one_inferior_data data
;
869 data
.recurse
= recurse
;
870 data
.inferiors
= &ids
;
872 /* Local thread groups. Either no explicit ids -- and we
873 print everything, or several explicit ids. In both cases,
874 we print more than one group, and have to use 'groups'
875 as the top-level element. */
876 ui_out_emit_list
list_emitter (uiout
, "groups");
877 update_thread_list ();
878 iterate_over_inferiors (print_one_inferior
, &data
);
883 mi_cmd_data_list_register_names (const char *command
, char **argv
, int argc
)
885 struct gdbarch
*gdbarch
;
886 struct ui_out
*uiout
= current_uiout
;
890 /* Note that the test for a valid register must include checking the
891 gdbarch_register_name because gdbarch_num_regs may be allocated
892 for the union of the register sets within a family of related
893 processors. In this case, some entries of gdbarch_register_name
894 will change depending upon the particular processor being
897 gdbarch
= get_current_arch ();
898 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
900 ui_out_emit_list
list_emitter (uiout
, "register-names");
902 if (argc
== 0) /* No args, just do all the regs. */
908 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
909 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
910 uiout
->field_string (NULL
, "");
912 uiout
->field_string (NULL
, gdbarch_register_name (gdbarch
, regnum
));
916 /* Else, list of register #s, just do listed regs. */
917 for (i
= 0; i
< argc
; i
++)
919 regnum
= atoi (argv
[i
]);
920 if (regnum
< 0 || regnum
>= numregs
)
921 error (_("bad register number"));
923 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
924 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
925 uiout
->field_string (NULL
, "");
927 uiout
->field_string (NULL
, gdbarch_register_name (gdbarch
, regnum
));
932 mi_cmd_data_list_changed_registers (const char *command
, char **argv
, int argc
)
934 static std::unique_ptr
<struct regcache
> this_regs
;
935 struct ui_out
*uiout
= current_uiout
;
936 std::unique_ptr
<struct regcache
> prev_regs
;
937 struct gdbarch
*gdbarch
;
938 int regnum
, numregs
, changed
;
941 /* The last time we visited this function, the current frame's
942 register contents were saved in THIS_REGS. Move THIS_REGS over
943 to PREV_REGS, and refresh THIS_REGS with the now-current register
946 prev_regs
= std::move (this_regs
);
947 this_regs
= frame_save_as_regcache (get_selected_frame (NULL
));
949 /* Note that the test for a valid register must include checking the
950 gdbarch_register_name because gdbarch_num_regs may be allocated
951 for the union of the register sets within a family of related
952 processors. In this case, some entries of gdbarch_register_name
953 will change depending upon the particular processor being
956 gdbarch
= this_regs
->arch ();
957 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
959 ui_out_emit_list
list_emitter (uiout
, "changed-registers");
963 /* No args, just do all the regs. */
968 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
969 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
971 changed
= register_changed_p (regnum
, prev_regs
.get (),
974 error (_("-data-list-changed-registers: "
975 "Unable to read register contents."));
977 uiout
->field_int (NULL
, regnum
);
981 /* Else, list of register #s, just do listed regs. */
982 for (i
= 0; i
< argc
; i
++)
984 regnum
= atoi (argv
[i
]);
988 && gdbarch_register_name (gdbarch
, regnum
) != NULL
989 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
991 changed
= register_changed_p (regnum
, prev_regs
.get (),
994 error (_("-data-list-changed-registers: "
995 "Unable to read register contents."));
997 uiout
->field_int (NULL
, regnum
);
1000 error (_("bad register number"));
1005 register_changed_p (int regnum
, struct regcache
*prev_regs
,
1006 struct regcache
*this_regs
)
1008 struct gdbarch
*gdbarch
= this_regs
->arch ();
1009 struct value
*prev_value
, *this_value
;
1012 /* First time through or after gdbarch change consider all registers
1014 if (!prev_regs
|| prev_regs
->arch () != gdbarch
)
1017 /* Get register contents and compare. */
1018 prev_value
= prev_regs
->cooked_read_value (regnum
);
1019 this_value
= this_regs
->cooked_read_value (regnum
);
1020 gdb_assert (prev_value
!= NULL
);
1021 gdb_assert (this_value
!= NULL
);
1023 ret
= value_contents_eq (prev_value
, 0, this_value
, 0,
1024 register_size (gdbarch
, regnum
)) == 0;
1026 release_value (prev_value
);
1027 release_value (this_value
);
1028 value_free (prev_value
);
1029 value_free (this_value
);
1033 /* Return a list of register number and value pairs. The valid
1034 arguments expected are: a letter indicating the format in which to
1035 display the registers contents. This can be one of: x
1036 (hexadecimal), d (decimal), N (natural), t (binary), o (octal), r
1037 (raw). After the format argument there can be a sequence of
1038 numbers, indicating which registers to fetch the content of. If
1039 the format is the only argument, a list of all the registers with
1040 their values is returned. */
1043 mi_cmd_data_list_register_values (const char *command
, char **argv
, int argc
)
1045 struct ui_out
*uiout
= current_uiout
;
1046 struct frame_info
*frame
;
1047 struct gdbarch
*gdbarch
;
1048 int regnum
, numregs
, format
;
1050 int skip_unavailable
= 0;
1056 static const struct mi_opt opts
[] =
1058 {"-skip-unavailable", SKIP_UNAVAILABLE
, 0},
1062 /* Note that the test for a valid register must include checking the
1063 gdbarch_register_name because gdbarch_num_regs may be allocated
1064 for the union of the register sets within a family of related
1065 processors. In this case, some entries of gdbarch_register_name
1066 will change depending upon the particular processor being
1072 int opt
= mi_getopt ("-data-list-register-values", argc
, argv
,
1073 opts
, &oind
, &oarg
);
1077 switch ((enum opt
) opt
)
1079 case SKIP_UNAVAILABLE
:
1080 skip_unavailable
= 1;
1085 if (argc
- oind
< 1)
1086 error (_("-data-list-register-values: Usage: "
1087 "-data-list-register-values [--skip-unavailable] <format>"
1088 " [<regnum1>...<regnumN>]"));
1090 format
= (int) argv
[oind
][0];
1092 frame
= get_selected_frame (NULL
);
1093 gdbarch
= get_frame_arch (frame
);
1094 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1096 ui_out_emit_list
list_emitter (uiout
, "register-values");
1098 if (argc
- oind
== 1)
1100 /* No args, beside the format: do all the regs. */
1105 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1106 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1109 output_register (frame
, regnum
, format
, skip_unavailable
);
1113 /* Else, list of register #s, just do listed regs. */
1114 for (i
= 1 + oind
; i
< argc
; i
++)
1116 regnum
= atoi (argv
[i
]);
1120 && gdbarch_register_name (gdbarch
, regnum
) != NULL
1121 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
1122 output_register (frame
, regnum
, format
, skip_unavailable
);
1124 error (_("bad register number"));
1128 /* Output one register REGNUM's contents in the desired FORMAT. If
1129 SKIP_UNAVAILABLE is true, skip the register if it is
1133 output_register (struct frame_info
*frame
, int regnum
, int format
,
1134 int skip_unavailable
)
1136 struct ui_out
*uiout
= current_uiout
;
1137 struct value
*val
= value_of_register (regnum
, frame
);
1138 struct value_print_options opts
;
1140 if (skip_unavailable
&& !value_entirely_available (val
))
1143 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1144 uiout
->field_int ("number", regnum
);
1154 get_formatted_print_options (&opts
, format
);
1156 val_print (value_type (val
),
1157 value_embedded_offset (val
), 0,
1158 &stb
, 0, val
, &opts
, current_language
);
1159 uiout
->field_stream ("value", stb
);
1162 /* Write given values into registers. The registers and values are
1163 given as pairs. The corresponding MI command is
1164 -data-write-register-values <format>
1165 [<regnum1> <value1>...<regnumN> <valueN>] */
1167 mi_cmd_data_write_register_values (const char *command
, char **argv
, int argc
)
1169 struct regcache
*regcache
;
1170 struct gdbarch
*gdbarch
;
1173 /* Note that the test for a valid register must include checking the
1174 gdbarch_register_name because gdbarch_num_regs may be allocated
1175 for the union of the register sets within a family of related
1176 processors. In this case, some entries of gdbarch_register_name
1177 will change depending upon the particular processor being
1180 regcache
= get_current_regcache ();
1181 gdbarch
= regcache
->arch ();
1182 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1185 error (_("-data-write-register-values: Usage: -data-write-register-"
1186 "values <format> [<regnum1> <value1>...<regnumN> <valueN>]"));
1188 if (!target_has_registers
)
1189 error (_("-data-write-register-values: No registers."));
1192 error (_("-data-write-register-values: No regs and values specified."));
1195 error (_("-data-write-register-values: "
1196 "Regs and vals are not in pairs."));
1198 for (i
= 1; i
< argc
; i
= i
+ 2)
1200 int regnum
= atoi (argv
[i
]);
1202 if (regnum
>= 0 && regnum
< numregs
1203 && gdbarch_register_name (gdbarch
, regnum
)
1204 && *gdbarch_register_name (gdbarch
, regnum
))
1208 /* Get the value as a number. */
1209 value
= parse_and_eval_address (argv
[i
+ 1]);
1211 /* Write it down. */
1212 regcache_cooked_write_signed (regcache
, regnum
, value
);
1215 error (_("bad register number"));
1219 /* Evaluate the value of the argument. The argument is an
1220 expression. If the expression contains spaces it needs to be
1221 included in double quotes. */
1224 mi_cmd_data_evaluate_expression (const char *command
, char **argv
, int argc
)
1227 struct value_print_options opts
;
1228 struct ui_out
*uiout
= current_uiout
;
1231 error (_("-data-evaluate-expression: "
1232 "Usage: -data-evaluate-expression expression"));
1234 expression_up expr
= parse_expression (argv
[0]);
1236 val
= evaluate_expression (expr
.get ());
1240 /* Print the result of the expression evaluation. */
1241 get_user_print_options (&opts
);
1243 common_val_print (val
, &stb
, 0, &opts
, current_language
);
1245 uiout
->field_stream ("value", stb
);
1248 /* This is the -data-read-memory command.
1250 ADDR: start address of data to be dumped.
1251 WORD-FORMAT: a char indicating format for the ``word''. See
1253 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
1254 NR_ROW: Number of rows.
1255 NR_COL: The number of colums (words per row).
1256 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
1257 ASCHAR for unprintable characters.
1259 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
1260 displayes them. Returns:
1262 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
1265 The number of bytes read is SIZE*ROW*COL. */
1268 mi_cmd_data_read_memory (const char *command
, char **argv
, int argc
)
1270 struct gdbarch
*gdbarch
= get_current_arch ();
1271 struct ui_out
*uiout
= current_uiout
;
1273 long total_bytes
, nr_cols
, nr_rows
;
1275 struct type
*word_type
;
1287 static const struct mi_opt opts
[] =
1289 {"o", OFFSET_OPT
, 1},
1295 int opt
= mi_getopt ("-data-read-memory", argc
, argv
, opts
,
1300 switch ((enum opt
) opt
)
1303 offset
= atol (oarg
);
1310 if (argc
< 5 || argc
> 6)
1311 error (_("-data-read-memory: Usage: "
1312 "ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR]."));
1314 /* Extract all the arguments. */
1316 /* Start address of the memory dump. */
1317 addr
= parse_and_eval_address (argv
[0]) + offset
;
1318 /* The format character to use when displaying a memory word. See
1319 the ``x'' command. */
1320 word_format
= argv
[1][0];
1321 /* The size of the memory word. */
1322 word_size
= atol (argv
[2]);
1326 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1330 word_type
= builtin_type (gdbarch
)->builtin_int16
;
1334 word_type
= builtin_type (gdbarch
)->builtin_int32
;
1338 word_type
= builtin_type (gdbarch
)->builtin_int64
;
1342 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1345 /* The number of rows. */
1346 nr_rows
= atol (argv
[3]);
1348 error (_("-data-read-memory: invalid number of rows."));
1350 /* Number of bytes per row. */
1351 nr_cols
= atol (argv
[4]);
1353 error (_("-data-read-memory: invalid number of columns."));
1355 /* The un-printable character when printing ascii. */
1361 /* Create a buffer and read it in. */
1362 total_bytes
= word_size
* nr_rows
* nr_cols
;
1364 gdb::byte_vector
mbuf (total_bytes
);
1366 /* Dispatch memory reads to the topmost target, not the flattened
1368 nr_bytes
= target_read (current_target
.beneath
,
1369 TARGET_OBJECT_MEMORY
, NULL
, mbuf
.data (),
1372 error (_("Unable to read memory."));
1374 /* Output the header information. */
1375 uiout
->field_core_addr ("addr", gdbarch
, addr
);
1376 uiout
->field_int ("nr-bytes", nr_bytes
);
1377 uiout
->field_int ("total-bytes", total_bytes
);
1378 uiout
->field_core_addr ("next-row", gdbarch
, addr
+ word_size
* nr_cols
);
1379 uiout
->field_core_addr ("prev-row", gdbarch
, addr
- word_size
* nr_cols
);
1380 uiout
->field_core_addr ("next-page", gdbarch
, addr
+ total_bytes
);
1381 uiout
->field_core_addr ("prev-page", gdbarch
, addr
- total_bytes
);
1383 /* Build the result as a two dimentional table. */
1390 ui_out_emit_list
list_emitter (uiout
, "memory");
1391 for (row
= 0, row_byte
= 0;
1393 row
++, row_byte
+= nr_cols
* word_size
)
1397 struct value_print_options opts
;
1399 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1400 uiout
->field_core_addr ("addr", gdbarch
, addr
+ row_byte
);
1401 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr +
1404 ui_out_emit_list
list_data_emitter (uiout
, "data");
1405 get_formatted_print_options (&opts
, word_format
);
1406 for (col
= 0, col_byte
= row_byte
;
1408 col
++, col_byte
+= word_size
)
1410 if (col_byte
+ word_size
> nr_bytes
)
1412 uiout
->field_string (NULL
, "N/A");
1417 print_scalar_formatted (&mbuf
[col_byte
], word_type
, &opts
,
1418 word_asize
, &stream
);
1419 uiout
->field_stream (NULL
, stream
);
1429 for (byte
= row_byte
;
1430 byte
< row_byte
+ word_size
* nr_cols
; byte
++)
1432 if (byte
>= nr_bytes
)
1434 else if (mbuf
[byte
] < 32 || mbuf
[byte
] > 126)
1435 stream
.putc (aschar
);
1437 stream
.putc (mbuf
[byte
]);
1439 uiout
->field_stream ("ascii", stream
);
1446 mi_cmd_data_read_memory_bytes (const char *command
, char **argv
, int argc
)
1448 struct gdbarch
*gdbarch
= get_current_arch ();
1449 struct ui_out
*uiout
= current_uiout
;
1453 int unit_size
= gdbarch_addressable_memory_unit_size (gdbarch
);
1460 static const struct mi_opt opts
[] =
1462 {"o", OFFSET_OPT
, 1},
1468 int opt
= mi_getopt ("-data-read-memory-bytes", argc
, argv
, opts
,
1472 switch ((enum opt
) opt
)
1475 offset
= atol (oarg
);
1483 error (_("Usage: [ -o OFFSET ] ADDR LENGTH."));
1485 addr
= parse_and_eval_address (argv
[0]) + offset
;
1486 length
= atol (argv
[1]);
1488 std::vector
<memory_read_result
> result
1489 = read_memory_robust (current_target
.beneath
, addr
, length
);
1491 if (result
.size () == 0)
1492 error (_("Unable to read memory."));
1494 ui_out_emit_list
list_emitter (uiout
, "memory");
1495 for (const memory_read_result
&read_result
: result
)
1497 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1499 uiout
->field_core_addr ("begin", gdbarch
, read_result
.begin
);
1500 uiout
->field_core_addr ("offset", gdbarch
, read_result
.begin
- addr
);
1501 uiout
->field_core_addr ("end", gdbarch
, read_result
.end
);
1503 std::string data
= bin2hex (read_result
.data
.get (),
1504 (read_result
.end
- read_result
.begin
)
1506 uiout
->field_string ("contents", data
.c_str ());
1510 /* Implementation of the -data-write_memory command.
1512 COLUMN_OFFSET: optional argument. Must be preceded by '-o'. The
1513 offset from the beginning of the memory grid row where the cell to
1515 ADDR: start address of the row in the memory grid where the memory
1516 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
1517 the location to write to.
1518 FORMAT: a char indicating format for the ``word''. See
1520 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
1521 VALUE: value to be written into the memory address.
1523 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1528 mi_cmd_data_write_memory (const char *command
, char **argv
, int argc
)
1530 struct gdbarch
*gdbarch
= get_current_arch ();
1531 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1534 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1535 enough when using a compiler other than GCC. */
1544 static const struct mi_opt opts
[] =
1546 {"o", OFFSET_OPT
, 1},
1552 int opt
= mi_getopt ("-data-write-memory", argc
, argv
, opts
,
1557 switch ((enum opt
) opt
)
1560 offset
= atol (oarg
);
1568 error (_("-data-write-memory: Usage: "
1569 "[-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE."));
1571 /* Extract all the arguments. */
1572 /* Start address of the memory dump. */
1573 addr
= parse_and_eval_address (argv
[0]);
1574 /* The size of the memory word. */
1575 word_size
= atol (argv
[2]);
1577 /* Calculate the real address of the write destination. */
1578 addr
+= (offset
* word_size
);
1580 /* Get the value as a number. */
1581 value
= parse_and_eval_address (argv
[3]);
1582 /* Get the value into an array. */
1583 gdb::byte_vector
buffer (word_size
);
1584 store_signed_integer (buffer
.data (), word_size
, byte_order
, value
);
1585 /* Write it down to memory. */
1586 write_memory_with_notification (addr
, buffer
.data (), word_size
);
1589 /* Implementation of the -data-write-memory-bytes command.
1592 DATA: string of bytes to write at that address
1593 COUNT: number of bytes to be filled (decimal integer). */
1596 mi_cmd_data_write_memory_bytes (const char *command
, char **argv
, int argc
)
1600 size_t len_hex
, len_bytes
, len_units
, i
, steps
, remaining_units
;
1601 long int count_units
;
1604 if (argc
!= 2 && argc
!= 3)
1605 error (_("Usage: ADDR DATA [COUNT]."));
1607 addr
= parse_and_eval_address (argv
[0]);
1609 len_hex
= strlen (cdata
);
1610 unit_size
= gdbarch_addressable_memory_unit_size (get_current_arch ());
1612 if (len_hex
% (unit_size
* 2) != 0)
1613 error (_("Hex-encoded '%s' must represent an integral number of "
1614 "addressable memory units."),
1617 len_bytes
= len_hex
/ 2;
1618 len_units
= len_bytes
/ unit_size
;
1621 count_units
= strtoul (argv
[2], NULL
, 10);
1623 count_units
= len_units
;
1625 gdb::byte_vector
databuf (len_bytes
);
1627 for (i
= 0; i
< len_bytes
; ++i
)
1630 if (sscanf (cdata
+ i
* 2, "%02x", &x
) != 1)
1631 error (_("Invalid argument"));
1632 databuf
[i
] = (gdb_byte
) x
;
1635 gdb::byte_vector data
;
1636 if (len_units
< count_units
)
1638 /* Pattern is made of less units than count:
1639 repeat pattern to fill memory. */
1640 data
= gdb::byte_vector (count_units
* unit_size
);
1642 /* Number of times the pattern is entirely repeated. */
1643 steps
= count_units
/ len_units
;
1644 /* Number of remaining addressable memory units. */
1645 remaining_units
= count_units
% len_units
;
1646 for (i
= 0; i
< steps
; i
++)
1647 memcpy (&data
[i
* len_bytes
], &databuf
[0], len_bytes
);
1649 if (remaining_units
> 0)
1650 memcpy (&data
[steps
* len_bytes
], &databuf
[0],
1651 remaining_units
* unit_size
);
1655 /* Pattern is longer than or equal to count:
1656 just copy count addressable memory units. */
1657 data
= std::move (databuf
);
1660 write_memory_with_notification (addr
, data
.data (), count_units
);
1664 mi_cmd_enable_timings (const char *command
, char **argv
, int argc
)
1670 if (strcmp (argv
[0], "yes") == 0)
1672 else if (strcmp (argv
[0], "no") == 0)
1683 error (_("-enable-timings: Usage: %s {yes|no}"), command
);
1687 mi_cmd_list_features (const char *command
, char **argv
, int argc
)
1691 struct ui_out
*uiout
= current_uiout
;
1693 ui_out_emit_list
list_emitter (uiout
, "features");
1694 uiout
->field_string (NULL
, "frozen-varobjs");
1695 uiout
->field_string (NULL
, "pending-breakpoints");
1696 uiout
->field_string (NULL
, "thread-info");
1697 uiout
->field_string (NULL
, "data-read-memory-bytes");
1698 uiout
->field_string (NULL
, "breakpoint-notifications");
1699 uiout
->field_string (NULL
, "ada-task-info");
1700 uiout
->field_string (NULL
, "language-option");
1701 uiout
->field_string (NULL
, "info-gdb-mi-command");
1702 uiout
->field_string (NULL
, "undefined-command-error-code");
1703 uiout
->field_string (NULL
, "exec-run-start-option");
1705 if (ext_lang_initialized_p (get_ext_lang_defn (EXT_LANG_PYTHON
)))
1706 uiout
->field_string (NULL
, "python");
1711 error (_("-list-features should be passed no arguments"));
1715 mi_cmd_list_target_features (const char *command
, char **argv
, int argc
)
1719 struct ui_out
*uiout
= current_uiout
;
1721 ui_out_emit_list
list_emitter (uiout
, "features");
1723 uiout
->field_string (NULL
, "async");
1724 if (target_can_execute_reverse
)
1725 uiout
->field_string (NULL
, "reverse");
1729 error (_("-list-target-features should be passed no arguments"));
1733 mi_cmd_add_inferior (const char *command
, char **argv
, int argc
)
1735 struct inferior
*inf
;
1738 error (_("-add-inferior should be passed no arguments"));
1740 inf
= add_inferior_with_spaces ();
1742 current_uiout
->field_fmt ("inferior", "i%d", inf
->num
);
1745 /* Callback used to find the first inferior other than the current
1749 get_other_inferior (struct inferior
*inf
, void *arg
)
1751 if (inf
== current_inferior ())
1758 mi_cmd_remove_inferior (const char *command
, char **argv
, int argc
)
1761 struct inferior
*inf
;
1764 error (_("-remove-inferior should be passed a single argument"));
1766 if (sscanf (argv
[0], "i%d", &id
) != 1)
1767 error (_("the thread group id is syntactically invalid"));
1769 inf
= find_inferior_id (id
);
1771 error (_("the specified thread group does not exist"));
1774 error (_("cannot remove an active inferior"));
1776 if (inf
== current_inferior ())
1778 struct thread_info
*tp
= 0;
1779 struct inferior
*new_inferior
1780 = iterate_over_inferiors (get_other_inferior
, NULL
);
1782 if (new_inferior
== NULL
)
1783 error (_("Cannot remove last inferior"));
1785 set_current_inferior (new_inferior
);
1786 if (new_inferior
->pid
!= 0)
1787 tp
= any_thread_of_process (new_inferior
->pid
);
1788 switch_to_thread (tp
? tp
->ptid
: null_ptid
);
1789 set_current_program_space (new_inferior
->pspace
);
1792 delete_inferior (inf
);
1797 /* Execute a command within a safe environment.
1798 Return <0 for error; >=0 for ok.
1800 args->action will tell mi_execute_command what action
1801 to perform after the given command has executed (display/suppress
1802 prompt, display error). */
1805 captured_mi_execute_command (struct ui_out
*uiout
, struct mi_parse
*context
)
1807 struct mi_interp
*mi
= (struct mi_interp
*) command_interp ();
1810 current_command_ts
= context
->cmd_start
;
1812 scoped_restore save_token
= make_scoped_restore (¤t_token
,
1815 running_result_record_printed
= 0;
1817 switch (context
->op
)
1820 /* A MI command was read from the input stream. */
1822 /* FIXME: gdb_???? */
1823 fprintf_unfiltered (mi
->raw_stdout
,
1824 " token=`%s' command=`%s' args=`%s'\n",
1825 context
->token
, context
->command
, context
->args
);
1827 mi_cmd_execute (context
);
1829 /* Print the result if there were no errors.
1831 Remember that on the way out of executing a command, you have
1832 to directly use the mi_interp's uiout, since the command
1833 could have reset the interpreter, in which case the current
1834 uiout will most likely crash in the mi_out_* routines. */
1835 if (!running_result_record_printed
)
1837 fputs_unfiltered (context
->token
, mi
->raw_stdout
);
1838 /* There's no particularly good reason why target-connect results
1839 in not ^done. Should kill ^connected for MI3. */
1840 fputs_unfiltered (strcmp (context
->command
, "target-select") == 0
1841 ? "^connected" : "^done", mi
->raw_stdout
);
1842 mi_out_put (uiout
, mi
->raw_stdout
);
1843 mi_out_rewind (uiout
);
1844 mi_print_timing_maybe (mi
->raw_stdout
);
1845 fputs_unfiltered ("\n", mi
->raw_stdout
);
1848 /* The command does not want anything to be printed. In that
1849 case, the command probably should not have written anything
1850 to uiout, but in case it has written something, discard it. */
1851 mi_out_rewind (uiout
);
1858 /* A CLI command was read from the input stream. */
1859 /* This "feature" will be removed as soon as we have a
1860 complete set of mi commands. */
1861 /* Echo the command on the console. */
1862 fprintf_unfiltered (gdb_stdlog
, "%s\n", context
->command
);
1863 /* Call the "console" interpreter. */
1864 argv
[0] = (char *) INTERP_CONSOLE
;
1865 argv
[1] = context
->command
;
1866 mi_cmd_interpreter_exec ("-interpreter-exec", argv
, 2);
1868 /* If we changed interpreters, DON'T print out anything. */
1869 if (current_interp_named_p (INTERP_MI
)
1870 || current_interp_named_p (INTERP_MI1
)
1871 || current_interp_named_p (INTERP_MI2
)
1872 || current_interp_named_p (INTERP_MI3
))
1874 if (!running_result_record_printed
)
1876 fputs_unfiltered (context
->token
, mi
->raw_stdout
);
1877 fputs_unfiltered ("^done", mi
->raw_stdout
);
1878 mi_out_put (uiout
, mi
->raw_stdout
);
1879 mi_out_rewind (uiout
);
1880 mi_print_timing_maybe (mi
->raw_stdout
);
1881 fputs_unfiltered ("\n", mi
->raw_stdout
);
1884 mi_out_rewind (uiout
);
1891 /* Print a gdb exception to the MI output stream. */
1894 mi_print_exception (const char *token
, struct gdb_exception exception
)
1896 struct mi_interp
*mi
= (struct mi_interp
*) current_interpreter ();
1898 fputs_unfiltered (token
, mi
->raw_stdout
);
1899 fputs_unfiltered ("^error,msg=\"", mi
->raw_stdout
);
1900 if (exception
.message
== NULL
)
1901 fputs_unfiltered ("unknown error", mi
->raw_stdout
);
1903 fputstr_unfiltered (exception
.message
, '"', mi
->raw_stdout
);
1904 fputs_unfiltered ("\"", mi
->raw_stdout
);
1906 switch (exception
.error
)
1908 case UNDEFINED_COMMAND_ERROR
:
1909 fputs_unfiltered (",code=\"undefined-command\"", mi
->raw_stdout
);
1913 fputs_unfiltered ("\n", mi
->raw_stdout
);
1916 /* Determine whether the parsed command already notifies the
1917 user_selected_context_changed observer. */
1920 command_notifies_uscc_observer (struct mi_parse
*command
)
1922 if (command
->op
== CLI_COMMAND
)
1924 /* CLI commands "thread" and "inferior" already send it. */
1925 return (strncmp (command
->command
, "thread ", 7) == 0
1926 || strncmp (command
->command
, "inferior ", 9) == 0);
1928 else /* MI_COMMAND */
1930 if (strcmp (command
->command
, "interpreter-exec") == 0
1931 && command
->argc
> 1)
1933 /* "thread" and "inferior" again, but through -interpreter-exec. */
1934 return (strncmp (command
->argv
[1], "thread ", 7) == 0
1935 || strncmp (command
->argv
[1], "inferior ", 9) == 0);
1939 /* -thread-select already sends it. */
1940 return strcmp (command
->command
, "thread-select") == 0;
1945 mi_execute_command (const char *cmd
, int from_tty
)
1948 std::unique_ptr
<struct mi_parse
> command
;
1950 /* This is to handle EOF (^D). We just quit gdb. */
1951 /* FIXME: we should call some API function here. */
1953 quit_force (NULL
, from_tty
);
1955 target_log_command (cmd
);
1959 command
= mi_parse (cmd
, &token
);
1961 CATCH (exception
, RETURN_MASK_ALL
)
1963 mi_print_exception (token
, exception
);
1968 if (command
!= NULL
)
1970 ptid_t previous_ptid
= inferior_ptid
;
1972 gdb::optional
<scoped_restore_tmpl
<int>> restore_suppress
;
1974 if (command
->cmd
!= NULL
&& command
->cmd
->suppress_notification
!= NULL
)
1975 restore_suppress
.emplace (command
->cmd
->suppress_notification
, 1);
1977 command
->token
= token
;
1981 command
->cmd_start
= new mi_timestamp ();
1982 timestamp (command
->cmd_start
);
1987 captured_mi_execute_command (current_uiout
, command
.get ());
1989 CATCH (result
, RETURN_MASK_ALL
)
1991 /* Like in start_event_loop, enable input and force display
1992 of the prompt. Otherwise, any command that calls
1993 async_disable_stdin, and then throws, will leave input
1995 async_enable_stdin ();
1996 current_ui
->prompt_state
= PROMPT_NEEDED
;
1998 /* The command execution failed and error() was called
2000 mi_print_exception (command
->token
, result
);
2001 mi_out_rewind (current_uiout
);
2005 bpstat_do_actions ();
2007 if (/* The notifications are only output when the top-level
2008 interpreter (specified on the command line) is MI. */
2009 interp_ui_out (top_level_interpreter ())->is_mi_like_p ()
2010 /* Don't try report anything if there are no threads --
2011 the program is dead. */
2012 && thread_count () != 0
2013 /* If the command already reports the thread change, no need to do it
2015 && !command_notifies_uscc_observer (command
.get ()))
2017 struct mi_interp
*mi
= (struct mi_interp
*) top_level_interpreter ();
2018 int report_change
= 0;
2020 if (command
->thread
== -1)
2022 report_change
= (!ptid_equal (previous_ptid
, null_ptid
)
2023 && !ptid_equal (inferior_ptid
, previous_ptid
)
2024 && !ptid_equal (inferior_ptid
, null_ptid
));
2026 else if (!ptid_equal (inferior_ptid
, null_ptid
))
2028 struct thread_info
*ti
= inferior_thread ();
2030 report_change
= (ti
->global_num
!= command
->thread
);
2035 observer_notify_user_selected_context_changed
2036 (USER_SELECTED_THREAD
| USER_SELECTED_FRAME
);
2043 mi_cmd_execute (struct mi_parse
*parse
)
2045 scoped_value_mark cleanup
= prepare_execute_command ();
2047 if (parse
->all
&& parse
->thread_group
!= -1)
2048 error (_("Cannot specify --thread-group together with --all"));
2050 if (parse
->all
&& parse
->thread
!= -1)
2051 error (_("Cannot specify --thread together with --all"));
2053 if (parse
->thread_group
!= -1 && parse
->thread
!= -1)
2054 error (_("Cannot specify --thread together with --thread-group"));
2056 if (parse
->frame
!= -1 && parse
->thread
== -1)
2057 error (_("Cannot specify --frame without --thread"));
2059 if (parse
->thread_group
!= -1)
2061 struct inferior
*inf
= find_inferior_id (parse
->thread_group
);
2062 struct thread_info
*tp
= 0;
2065 error (_("Invalid thread group for the --thread-group option"));
2067 set_current_inferior (inf
);
2068 /* This behaviour means that if --thread-group option identifies
2069 an inferior with multiple threads, then a random one will be
2070 picked. This is not a problem -- frontend should always
2071 provide --thread if it wishes to operate on a specific
2074 tp
= any_live_thread_of_process (inf
->pid
);
2075 switch_to_thread (tp
? tp
->ptid
: null_ptid
);
2076 set_current_program_space (inf
->pspace
);
2079 if (parse
->thread
!= -1)
2081 struct thread_info
*tp
= find_thread_global_id (parse
->thread
);
2084 error (_("Invalid thread id: %d"), parse
->thread
);
2086 if (is_exited (tp
->ptid
))
2087 error (_("Thread id: %d has terminated"), parse
->thread
);
2089 switch_to_thread (tp
->ptid
);
2092 if (parse
->frame
!= -1)
2094 struct frame_info
*fid
;
2095 int frame
= parse
->frame
;
2097 fid
= find_relative_frame (get_current_frame (), &frame
);
2099 /* find_relative_frame was successful */
2102 error (_("Invalid frame id: %d"), frame
);
2105 gdb::optional
<scoped_restore_current_language
> lang_saver
;
2106 if (parse
->language
!= language_unknown
)
2108 lang_saver
.emplace ();
2109 set_language (parse
->language
);
2112 current_context
= parse
;
2114 if (parse
->cmd
->argv_func
!= NULL
)
2116 parse
->cmd
->argv_func (parse
->command
, parse
->argv
, parse
->argc
);
2118 else if (parse
->cmd
->cli
.cmd
!= 0)
2120 /* FIXME: DELETE THIS. */
2121 /* The operation is still implemented by a cli command. */
2122 /* Must be a synchronous one. */
2123 mi_execute_cli_command (parse
->cmd
->cli
.cmd
, parse
->cmd
->cli
.args_p
,
2128 /* FIXME: DELETE THIS. */
2131 stb
.puts ("Undefined mi command: ");
2132 stb
.putstr (parse
->command
, '"');
2133 stb
.puts (" (missing implementation)");
2139 /* FIXME: This is just a hack so we can get some extra commands going.
2140 We don't want to channel things through the CLI, but call libgdb directly.
2141 Use only for synchronous commands. */
2144 mi_execute_cli_command (const char *cmd
, int args_p
, const char *args
)
2148 std::string run
= cmd
;
2151 run
= run
+ " " + args
;
2153 /* FIXME: gdb_???? */
2154 fprintf_unfiltered (gdb_stdout
, "cli=%s run=%s\n",
2156 execute_command (run
.c_str (), 0 /* from_tty */ );
2161 mi_execute_async_cli_command (const char *cli_command
, char **argv
, int argc
)
2163 std::string run
= cli_command
;
2166 run
= run
+ " " + *argv
;
2170 execute_command (run
.c_str (), 0 /* from_tty */ );
2174 mi_load_progress (const char *section_name
,
2175 unsigned long sent_so_far
,
2176 unsigned long total_section
,
2177 unsigned long total_sent
,
2178 unsigned long grand_total
)
2180 using namespace std::chrono
;
2181 static steady_clock::time_point last_update
;
2182 static char *previous_sect_name
= NULL
;
2184 struct mi_interp
*mi
= (struct mi_interp
*) current_interpreter ();
2186 /* This function is called through deprecated_show_load_progress
2187 which means uiout may not be correct. Fix it for the duration
2188 of this function. */
2190 std::unique_ptr
<ui_out
> uiout
;
2192 if (current_interp_named_p (INTERP_MI
)
2193 || current_interp_named_p (INTERP_MI2
))
2194 uiout
.reset (mi_out_new (2));
2195 else if (current_interp_named_p (INTERP_MI1
))
2196 uiout
.reset (mi_out_new (1));
2197 else if (current_interp_named_p (INTERP_MI3
))
2198 uiout
.reset (mi_out_new (3));
2202 scoped_restore save_uiout
2203 = make_scoped_restore (¤t_uiout
, uiout
.get ());
2205 new_section
= (previous_sect_name
?
2206 strcmp (previous_sect_name
, section_name
) : 1);
2209 xfree (previous_sect_name
);
2210 previous_sect_name
= xstrdup (section_name
);
2213 fputs_unfiltered (current_token
, mi
->raw_stdout
);
2214 fputs_unfiltered ("+download", mi
->raw_stdout
);
2216 ui_out_emit_tuple
tuple_emitter (uiout
.get (), NULL
);
2217 uiout
->field_string ("section", section_name
);
2218 uiout
->field_int ("section-size", total_section
);
2219 uiout
->field_int ("total-size", grand_total
);
2221 mi_out_put (uiout
.get (), mi
->raw_stdout
);
2222 fputs_unfiltered ("\n", mi
->raw_stdout
);
2223 gdb_flush (mi
->raw_stdout
);
2226 steady_clock::time_point time_now
= steady_clock::now ();
2227 if (time_now
- last_update
> milliseconds (500))
2229 last_update
= time_now
;
2231 fputs_unfiltered (current_token
, mi
->raw_stdout
);
2232 fputs_unfiltered ("+download", mi
->raw_stdout
);
2234 ui_out_emit_tuple
tuple_emitter (uiout
.get (), NULL
);
2235 uiout
->field_string ("section", section_name
);
2236 uiout
->field_int ("section-sent", sent_so_far
);
2237 uiout
->field_int ("section-size", total_section
);
2238 uiout
->field_int ("total-sent", total_sent
);
2239 uiout
->field_int ("total-size", grand_total
);
2241 mi_out_put (uiout
.get (), mi
->raw_stdout
);
2242 fputs_unfiltered ("\n", mi
->raw_stdout
);
2243 gdb_flush (mi
->raw_stdout
);
2248 timestamp (struct mi_timestamp
*tv
)
2250 using namespace std::chrono
;
2252 tv
->wallclock
= steady_clock::now ();
2253 run_time_clock::now (tv
->utime
, tv
->stime
);
2257 print_diff_now (struct ui_file
*file
, struct mi_timestamp
*start
)
2259 struct mi_timestamp now
;
2262 print_diff (file
, start
, &now
);
2266 mi_print_timing_maybe (struct ui_file
*file
)
2268 /* If the command is -enable-timing then do_timings may be true
2269 whilst current_command_ts is not initialized. */
2270 if (do_timings
&& current_command_ts
)
2271 print_diff_now (file
, current_command_ts
);
2275 print_diff (struct ui_file
*file
, struct mi_timestamp
*start
,
2276 struct mi_timestamp
*end
)
2278 using namespace std::chrono
;
2280 duration
<double> wallclock
= end
->wallclock
- start
->wallclock
;
2281 duration
<double> utime
= end
->utime
- start
->utime
;
2282 duration
<double> stime
= end
->stime
- start
->stime
;
2286 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
2287 wallclock
.count (), utime
.count (), stime
.count ());
2291 mi_cmd_trace_define_variable (const char *command
, char **argv
, int argc
)
2293 LONGEST initval
= 0;
2294 struct trace_state_variable
*tsv
;
2297 if (argc
!= 1 && argc
!= 2)
2298 error (_("Usage: -trace-define-variable VARIABLE [VALUE]"));
2302 error (_("Name of trace variable should start with '$'"));
2304 validate_trace_state_variable_name (name
);
2306 tsv
= find_trace_state_variable (name
);
2308 tsv
= create_trace_state_variable (name
);
2311 initval
= value_as_long (parse_and_eval (argv
[1]));
2313 tsv
->initial_value
= initval
;
2317 mi_cmd_trace_list_variables (const char *command
, char **argv
, int argc
)
2320 error (_("-trace-list-variables: no arguments allowed"));
2322 tvariables_info_1 ();
2326 mi_cmd_trace_find (const char *command
, char **argv
, int argc
)
2331 error (_("trace selection mode is required"));
2335 if (strcmp (mode
, "none") == 0)
2337 tfind_1 (tfind_number
, -1, 0, 0, 0);
2341 check_trace_running (current_trace_status ());
2343 if (strcmp (mode
, "frame-number") == 0)
2346 error (_("frame number is required"));
2347 tfind_1 (tfind_number
, atoi (argv
[1]), 0, 0, 0);
2349 else if (strcmp (mode
, "tracepoint-number") == 0)
2352 error (_("tracepoint number is required"));
2353 tfind_1 (tfind_tp
, atoi (argv
[1]), 0, 0, 0);
2355 else if (strcmp (mode
, "pc") == 0)
2358 error (_("PC is required"));
2359 tfind_1 (tfind_pc
, 0, parse_and_eval_address (argv
[1]), 0, 0);
2361 else if (strcmp (mode
, "pc-inside-range") == 0)
2364 error (_("Start and end PC are required"));
2365 tfind_1 (tfind_range
, 0, parse_and_eval_address (argv
[1]),
2366 parse_and_eval_address (argv
[2]), 0);
2368 else if (strcmp (mode
, "pc-outside-range") == 0)
2371 error (_("Start and end PC are required"));
2372 tfind_1 (tfind_outside
, 0, parse_and_eval_address (argv
[1]),
2373 parse_and_eval_address (argv
[2]), 0);
2375 else if (strcmp (mode
, "line") == 0)
2378 error (_("Line is required"));
2380 std::vector
<symtab_and_line
> sals
2381 = decode_line_with_current_source (argv
[1],
2382 DECODE_LINE_FUNFIRSTLINE
);
2383 const symtab_and_line
&sal
= sals
[0];
2385 if (sal
.symtab
== 0)
2386 error (_("Could not find the specified line"));
2388 CORE_ADDR start_pc
, end_pc
;
2389 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2390 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, 0);
2392 error (_("Could not find the specified line"));
2395 error (_("Invalid mode '%s'"), mode
);
2397 if (has_stack_frames () || get_traceframe_number () >= 0)
2398 print_stack_frame (get_selected_frame (NULL
), 1, LOC_AND_ADDRESS
, 1);
2402 mi_cmd_trace_save (const char *command
, char **argv
, int argc
)
2404 int target_saves
= 0;
2405 int generate_ctf
= 0;
2412 TARGET_SAVE_OPT
, CTF_OPT
2414 static const struct mi_opt opts
[] =
2416 {"r", TARGET_SAVE_OPT
, 0},
2417 {"ctf", CTF_OPT
, 0},
2423 int opt
= mi_getopt ("-trace-save", argc
, argv
, opts
,
2428 switch ((enum opt
) opt
)
2430 case TARGET_SAVE_OPT
:
2439 if (argc
- oind
!= 1)
2440 error (_("Exactly one argument required "
2441 "(file in which to save trace data)"));
2443 filename
= argv
[oind
];
2446 trace_save_ctf (filename
, target_saves
);
2448 trace_save_tfile (filename
, target_saves
);
2452 mi_cmd_trace_start (const char *command
, char **argv
, int argc
)
2454 start_tracing (NULL
);
2458 mi_cmd_trace_status (const char *command
, char **argv
, int argc
)
2460 trace_status_mi (0);
2464 mi_cmd_trace_stop (const char *command
, char **argv
, int argc
)
2466 stop_tracing (NULL
);
2467 trace_status_mi (1);
2470 /* Implement the "-ada-task-info" command. */
2473 mi_cmd_ada_task_info (const char *command
, char **argv
, int argc
)
2475 if (argc
!= 0 && argc
!= 1)
2476 error (_("Invalid MI command"));
2478 print_ada_task_info (current_uiout
, argv
[0], current_inferior ());
2481 /* Print EXPRESSION according to VALUES. */
2484 print_variable_or_computed (const char *expression
, enum print_values values
)
2488 struct ui_out
*uiout
= current_uiout
;
2492 expression_up expr
= parse_expression (expression
);
2494 if (values
== PRINT_SIMPLE_VALUES
)
2495 val
= evaluate_type (expr
.get ());
2497 val
= evaluate_expression (expr
.get ());
2499 gdb::optional
<ui_out_emit_tuple
> tuple_emitter
;
2500 if (values
!= PRINT_NO_VALUES
)
2501 tuple_emitter
.emplace (uiout
, nullptr);
2502 uiout
->field_string ("name", expression
);
2506 case PRINT_SIMPLE_VALUES
:
2507 type
= check_typedef (value_type (val
));
2508 type_print (value_type (val
), "", &stb
, -1);
2509 uiout
->field_stream ("type", stb
);
2510 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
2511 && TYPE_CODE (type
) != TYPE_CODE_STRUCT
2512 && TYPE_CODE (type
) != TYPE_CODE_UNION
)
2514 struct value_print_options opts
;
2516 get_no_prettyformat_print_options (&opts
);
2518 common_val_print (val
, &stb
, 0, &opts
, current_language
);
2519 uiout
->field_stream ("value", stb
);
2522 case PRINT_ALL_VALUES
:
2524 struct value_print_options opts
;
2526 get_no_prettyformat_print_options (&opts
);
2528 common_val_print (val
, &stb
, 0, &opts
, current_language
);
2529 uiout
->field_stream ("value", stb
);
2535 /* Implement the "-trace-frame-collected" command. */
2538 mi_cmd_trace_frame_collected (const char *command
, char **argv
, int argc
)
2540 struct bp_location
*tloc
;
2542 struct collection_list
*clist
;
2543 struct collection_list tracepoint_list
, stepping_list
;
2544 struct traceframe_info
*tinfo
;
2546 enum print_values var_print_values
= PRINT_ALL_VALUES
;
2547 enum print_values comp_print_values
= PRINT_ALL_VALUES
;
2548 int registers_format
= 'x';
2549 int memory_contents
= 0;
2550 struct ui_out
*uiout
= current_uiout
;
2558 static const struct mi_opt opts
[] =
2560 {"-var-print-values", VAR_PRINT_VALUES
, 1},
2561 {"-comp-print-values", COMP_PRINT_VALUES
, 1},
2562 {"-registers-format", REGISTERS_FORMAT
, 1},
2563 {"-memory-contents", MEMORY_CONTENTS
, 0},
2570 int opt
= mi_getopt ("-trace-frame-collected", argc
, argv
, opts
,
2574 switch ((enum opt
) opt
)
2576 case VAR_PRINT_VALUES
:
2577 var_print_values
= mi_parse_print_values (oarg
);
2579 case COMP_PRINT_VALUES
:
2580 comp_print_values
= mi_parse_print_values (oarg
);
2582 case REGISTERS_FORMAT
:
2583 registers_format
= oarg
[0];
2584 case MEMORY_CONTENTS
:
2585 memory_contents
= 1;
2591 error (_("Usage: -trace-frame-collected "
2592 "[--var-print-values PRINT_VALUES] "
2593 "[--comp-print-values PRINT_VALUES] "
2594 "[--registers-format FORMAT]"
2595 "[--memory-contents]"));
2597 /* This throws an error is not inspecting a trace frame. */
2598 tloc
= get_traceframe_location (&stepping_frame
);
2600 /* This command only makes sense for the current frame, not the
2602 scoped_restore_current_thread restore_thread
;
2603 select_frame (get_current_frame ());
2605 encode_actions (tloc
, &tracepoint_list
, &stepping_list
);
2608 clist
= &stepping_list
;
2610 clist
= &tracepoint_list
;
2612 tinfo
= get_traceframe_info ();
2614 /* Explicitly wholly collected variables. */
2618 ui_out_emit_list
list_emitter (uiout
, "explicit-variables");
2619 const std::vector
<std::string
> &wholly_collected
2620 = clist
->wholly_collected ();
2621 for (size_t i
= 0; i
< wholly_collected
.size (); i
++)
2623 const std::string
&str
= wholly_collected
[i
];
2624 print_variable_or_computed (str
.c_str (), var_print_values
);
2628 /* Computed expressions. */
2633 ui_out_emit_list
list_emitter (uiout
, "computed-expressions");
2635 const std::vector
<std::string
> &computed
= clist
->computed ();
2636 for (size_t i
= 0; i
< computed
.size (); i
++)
2638 const std::string
&str
= computed
[i
];
2639 print_variable_or_computed (str
.c_str (), comp_print_values
);
2643 /* Registers. Given pseudo-registers, and that some architectures
2644 (like MIPS) actually hide the raw registers, we don't go through
2645 the trace frame info, but instead consult the register cache for
2646 register availability. */
2648 struct frame_info
*frame
;
2649 struct gdbarch
*gdbarch
;
2653 ui_out_emit_list
list_emitter (uiout
, "registers");
2655 frame
= get_selected_frame (NULL
);
2656 gdbarch
= get_frame_arch (frame
);
2657 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
2659 for (regnum
= 0; regnum
< numregs
; regnum
++)
2661 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
2662 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
2665 output_register (frame
, regnum
, registers_format
, 1);
2669 /* Trace state variables. */
2671 ui_out_emit_list
list_emitter (uiout
, "tvars");
2673 for (int tvar
: tinfo
->tvars
)
2675 struct trace_state_variable
*tsv
;
2677 tsv
= find_trace_state_variable_by_number (tvar
);
2679 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
2683 uiout
->field_fmt ("name", "$%s", tsv
->name
);
2685 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
2687 uiout
->field_int ("current", tsv
->value
);
2691 uiout
->field_skip ("name");
2692 uiout
->field_skip ("current");
2699 std::vector
<mem_range
> available_memory
;
2701 traceframe_available_memory (&available_memory
, 0, ULONGEST_MAX
);
2703 ui_out_emit_list
list_emitter (uiout
, "memory");
2705 for (const mem_range
&r
: available_memory
)
2707 struct gdbarch
*gdbarch
= target_gdbarch ();
2709 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
2711 uiout
->field_core_addr ("address", gdbarch
, r
.start
);
2712 uiout
->field_int ("length", r
.length
);
2714 gdb::byte_vector
data (r
.length
);
2716 if (memory_contents
)
2718 if (target_read_memory (r
.start
, data
.data (), r
.length
) == 0)
2720 std::string data_str
= bin2hex (data
.data (), r
.length
);
2721 uiout
->field_string ("contents", data_str
.c_str ());
2724 uiout
->field_skip ("contents");
2731 _initialize_mi_main (void)
2733 struct cmd_list_element
*c
;
2735 add_setshow_boolean_cmd ("mi-async", class_run
,
2737 Set whether MI asynchronous mode is enabled."), _("\
2738 Show whether MI asynchronous mode is enabled."), _("\
2739 Tells GDB whether MI should be in asynchronous mode."),
2740 set_mi_async_command
,
2741 show_mi_async_command
,
2745 /* Alias old "target-async" to "mi-async". */
2746 c
= add_alias_cmd ("target-async", "mi-async", class_run
, 0, &setlist
);
2747 deprecate_cmd (c
, "set mi-async");
2748 c
= add_alias_cmd ("target-async", "mi-async", class_run
, 0, &showlist
);
2749 deprecate_cmd (c
, "show mi-async");