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);
732 std::vector
<osdata_item
> *vec
;
734 auto n
= tree_
.find (pid_i
);
735 if (n
== tree_
.end ())
737 vec
= new std::vector
<osdata_item
>;
743 vec
->push_back (item
);
747 ui_out_emit_list
list_emitter (uiout
, "groups");
749 for (const osdata_item
&item
: data
->items
)
751 const std::string
*pid
= get_osdata_column (item
, "pid");
752 const std::string
*cmd
= get_osdata_column (item
, "command");
753 const std::string
*user
= get_osdata_column (item
, "user");
754 const std::string
*cores
= get_osdata_column (item
, "cores");
756 int pid_i
= strtoul (pid
->c_str (), NULL
, 0);
758 /* At present, the target will return all available processes
759 and if information about specific ones was required, we filter
760 undesired processes here. */
761 if (!ids
.empty () && ids
.find (pid_i
) == ids
.end ())
764 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
766 uiout
->field_fmt ("id", "%s", pid
->c_str ());
767 uiout
->field_string ("type", "process");
769 uiout
->field_string ("description", cmd
->c_str ());
771 uiout
->field_string ("user", user
->c_str ());
773 output_cores (uiout
, "cores", cores
->c_str ());
777 auto n
= tree_
.find (pid_i
);
778 if (n
!= tree_
.end ())
780 std::vector
<osdata_item
> *children
= n
->second
;
782 ui_out_emit_list
thread_list_emitter (uiout
, "threads");
784 for (const osdata_item
&child
: *children
)
786 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
787 const std::string
*tid
= get_osdata_column (child
, "tid");
788 const std::string
*tcore
= get_osdata_column (child
, "core");
790 uiout
->field_string ("id", tid
->c_str ());
792 uiout
->field_string ("core", tcore
->c_str ());
800 mi_cmd_list_thread_groups (const char *command
, char **argv
, int argc
)
802 struct ui_out
*uiout
= current_uiout
;
809 AVAILABLE_OPT
, RECURSE_OPT
811 static const struct mi_opt opts
[] =
813 {"-available", AVAILABLE_OPT
, 0},
814 {"-recurse", RECURSE_OPT
, 1},
823 int opt
= mi_getopt ("-list-thread-groups", argc
, argv
, opts
,
828 switch ((enum opt
) opt
)
834 if (strcmp (oarg
, "0") == 0)
836 else if (strcmp (oarg
, "1") == 0)
839 error (_("only '0' and '1' are valid values "
840 "for the '--recurse' option"));
845 for (; oind
< argc
; ++oind
)
850 if (*(argv
[oind
]) != 'i')
851 error (_("invalid syntax of group id '%s'"), argv
[oind
]);
853 inf
= strtoul (argv
[oind
] + 1, &end
, 0);
856 error (_("invalid syntax of group id '%s'"), argv
[oind
]);
862 list_available_thread_groups (ids
, recurse
);
864 else if (ids
.size () == 1)
866 /* Local thread groups, single id. */
867 int id
= *(ids
.begin ());
868 struct inferior
*inf
= find_inferior_id (id
);
871 error (_("Non-existent thread group id '%d'"), id
);
873 print_thread_info (uiout
, NULL
, inf
->pid
);
877 struct print_one_inferior_data data
;
879 data
.recurse
= recurse
;
880 data
.inferiors
= &ids
;
882 /* Local thread groups. Either no explicit ids -- and we
883 print everything, or several explicit ids. In both cases,
884 we print more than one group, and have to use 'groups'
885 as the top-level element. */
886 ui_out_emit_list
list_emitter (uiout
, "groups");
887 update_thread_list ();
888 iterate_over_inferiors (print_one_inferior
, &data
);
893 mi_cmd_data_list_register_names (const char *command
, char **argv
, int argc
)
895 struct gdbarch
*gdbarch
;
896 struct ui_out
*uiout
= current_uiout
;
900 /* Note that the test for a valid register must include checking the
901 gdbarch_register_name because gdbarch_num_regs may be allocated
902 for the union of the register sets within a family of related
903 processors. In this case, some entries of gdbarch_register_name
904 will change depending upon the particular processor being
907 gdbarch
= get_current_arch ();
908 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
910 ui_out_emit_list
list_emitter (uiout
, "register-names");
912 if (argc
== 0) /* No args, just do all the regs. */
918 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
919 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
920 uiout
->field_string (NULL
, "");
922 uiout
->field_string (NULL
, gdbarch_register_name (gdbarch
, regnum
));
926 /* Else, list of register #s, just do listed regs. */
927 for (i
= 0; i
< argc
; i
++)
929 regnum
= atoi (argv
[i
]);
930 if (regnum
< 0 || regnum
>= numregs
)
931 error (_("bad register number"));
933 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
934 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
935 uiout
->field_string (NULL
, "");
937 uiout
->field_string (NULL
, gdbarch_register_name (gdbarch
, regnum
));
942 mi_cmd_data_list_changed_registers (const char *command
, char **argv
, int argc
)
944 static std::unique_ptr
<struct regcache
> this_regs
;
945 struct ui_out
*uiout
= current_uiout
;
946 std::unique_ptr
<struct regcache
> prev_regs
;
947 struct gdbarch
*gdbarch
;
948 int regnum
, numregs
, changed
;
951 /* The last time we visited this function, the current frame's
952 register contents were saved in THIS_REGS. Move THIS_REGS over
953 to PREV_REGS, and refresh THIS_REGS with the now-current register
956 prev_regs
= std::move (this_regs
);
957 this_regs
= frame_save_as_regcache (get_selected_frame (NULL
));
959 /* Note that the test for a valid register must include checking the
960 gdbarch_register_name because gdbarch_num_regs may be allocated
961 for the union of the register sets within a family of related
962 processors. In this case, some entries of gdbarch_register_name
963 will change depending upon the particular processor being
966 gdbarch
= this_regs
->arch ();
967 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
969 ui_out_emit_list
list_emitter (uiout
, "changed-registers");
973 /* No args, just do all the regs. */
978 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
979 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
981 changed
= register_changed_p (regnum
, prev_regs
.get (),
984 error (_("-data-list-changed-registers: "
985 "Unable to read register contents."));
987 uiout
->field_int (NULL
, regnum
);
991 /* Else, list of register #s, just do listed regs. */
992 for (i
= 0; i
< argc
; i
++)
994 regnum
= atoi (argv
[i
]);
998 && gdbarch_register_name (gdbarch
, regnum
) != NULL
999 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
1001 changed
= register_changed_p (regnum
, prev_regs
.get (),
1004 error (_("-data-list-changed-registers: "
1005 "Unable to read register contents."));
1007 uiout
->field_int (NULL
, regnum
);
1010 error (_("bad register number"));
1015 register_changed_p (int regnum
, struct regcache
*prev_regs
,
1016 struct regcache
*this_regs
)
1018 struct gdbarch
*gdbarch
= this_regs
->arch ();
1019 struct value
*prev_value
, *this_value
;
1022 /* First time through or after gdbarch change consider all registers
1024 if (!prev_regs
|| prev_regs
->arch () != gdbarch
)
1027 /* Get register contents and compare. */
1028 prev_value
= prev_regs
->cooked_read_value (regnum
);
1029 this_value
= this_regs
->cooked_read_value (regnum
);
1030 gdb_assert (prev_value
!= NULL
);
1031 gdb_assert (this_value
!= NULL
);
1033 ret
= value_contents_eq (prev_value
, 0, this_value
, 0,
1034 register_size (gdbarch
, regnum
)) == 0;
1036 release_value (prev_value
);
1037 release_value (this_value
);
1038 value_free (prev_value
);
1039 value_free (this_value
);
1043 /* Return a list of register number and value pairs. The valid
1044 arguments expected are: a letter indicating the format in which to
1045 display the registers contents. This can be one of: x
1046 (hexadecimal), d (decimal), N (natural), t (binary), o (octal), r
1047 (raw). After the format argument there can be a sequence of
1048 numbers, indicating which registers to fetch the content of. If
1049 the format is the only argument, a list of all the registers with
1050 their values is returned. */
1053 mi_cmd_data_list_register_values (const char *command
, char **argv
, int argc
)
1055 struct ui_out
*uiout
= current_uiout
;
1056 struct frame_info
*frame
;
1057 struct gdbarch
*gdbarch
;
1058 int regnum
, numregs
, format
;
1060 int skip_unavailable
= 0;
1066 static const struct mi_opt opts
[] =
1068 {"-skip-unavailable", SKIP_UNAVAILABLE
, 0},
1072 /* Note that the test for a valid register must include checking the
1073 gdbarch_register_name because gdbarch_num_regs may be allocated
1074 for the union of the register sets within a family of related
1075 processors. In this case, some entries of gdbarch_register_name
1076 will change depending upon the particular processor being
1082 int opt
= mi_getopt ("-data-list-register-values", argc
, argv
,
1083 opts
, &oind
, &oarg
);
1087 switch ((enum opt
) opt
)
1089 case SKIP_UNAVAILABLE
:
1090 skip_unavailable
= 1;
1095 if (argc
- oind
< 1)
1096 error (_("-data-list-register-values: Usage: "
1097 "-data-list-register-values [--skip-unavailable] <format>"
1098 " [<regnum1>...<regnumN>]"));
1100 format
= (int) argv
[oind
][0];
1102 frame
= get_selected_frame (NULL
);
1103 gdbarch
= get_frame_arch (frame
);
1104 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1106 ui_out_emit_list
list_emitter (uiout
, "register-values");
1108 if (argc
- oind
== 1)
1110 /* No args, beside the format: do all the regs. */
1115 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1116 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1119 output_register (frame
, regnum
, format
, skip_unavailable
);
1123 /* Else, list of register #s, just do listed regs. */
1124 for (i
= 1 + oind
; i
< argc
; i
++)
1126 regnum
= atoi (argv
[i
]);
1130 && gdbarch_register_name (gdbarch
, regnum
) != NULL
1131 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
1132 output_register (frame
, regnum
, format
, skip_unavailable
);
1134 error (_("bad register number"));
1138 /* Output one register REGNUM's contents in the desired FORMAT. If
1139 SKIP_UNAVAILABLE is true, skip the register if it is
1143 output_register (struct frame_info
*frame
, int regnum
, int format
,
1144 int skip_unavailable
)
1146 struct ui_out
*uiout
= current_uiout
;
1147 struct value
*val
= value_of_register (regnum
, frame
);
1148 struct value_print_options opts
;
1150 if (skip_unavailable
&& !value_entirely_available (val
))
1153 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1154 uiout
->field_int ("number", regnum
);
1164 get_formatted_print_options (&opts
, format
);
1166 val_print (value_type (val
),
1167 value_embedded_offset (val
), 0,
1168 &stb
, 0, val
, &opts
, current_language
);
1169 uiout
->field_stream ("value", stb
);
1172 /* Write given values into registers. The registers and values are
1173 given as pairs. The corresponding MI command is
1174 -data-write-register-values <format>
1175 [<regnum1> <value1>...<regnumN> <valueN>] */
1177 mi_cmd_data_write_register_values (const char *command
, char **argv
, int argc
)
1179 struct regcache
*regcache
;
1180 struct gdbarch
*gdbarch
;
1183 /* Note that the test for a valid register must include checking the
1184 gdbarch_register_name because gdbarch_num_regs may be allocated
1185 for the union of the register sets within a family of related
1186 processors. In this case, some entries of gdbarch_register_name
1187 will change depending upon the particular processor being
1190 regcache
= get_current_regcache ();
1191 gdbarch
= regcache
->arch ();
1192 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1195 error (_("-data-write-register-values: Usage: -data-write-register-"
1196 "values <format> [<regnum1> <value1>...<regnumN> <valueN>]"));
1198 if (!target_has_registers
)
1199 error (_("-data-write-register-values: No registers."));
1202 error (_("-data-write-register-values: No regs and values specified."));
1205 error (_("-data-write-register-values: "
1206 "Regs and vals are not in pairs."));
1208 for (i
= 1; i
< argc
; i
= i
+ 2)
1210 int regnum
= atoi (argv
[i
]);
1212 if (regnum
>= 0 && regnum
< numregs
1213 && gdbarch_register_name (gdbarch
, regnum
)
1214 && *gdbarch_register_name (gdbarch
, regnum
))
1218 /* Get the value as a number. */
1219 value
= parse_and_eval_address (argv
[i
+ 1]);
1221 /* Write it down. */
1222 regcache_cooked_write_signed (regcache
, regnum
, value
);
1225 error (_("bad register number"));
1229 /* Evaluate the value of the argument. The argument is an
1230 expression. If the expression contains spaces it needs to be
1231 included in double quotes. */
1234 mi_cmd_data_evaluate_expression (const char *command
, char **argv
, int argc
)
1237 struct value_print_options opts
;
1238 struct ui_out
*uiout
= current_uiout
;
1241 error (_("-data-evaluate-expression: "
1242 "Usage: -data-evaluate-expression expression"));
1244 expression_up expr
= parse_expression (argv
[0]);
1246 val
= evaluate_expression (expr
.get ());
1250 /* Print the result of the expression evaluation. */
1251 get_user_print_options (&opts
);
1253 common_val_print (val
, &stb
, 0, &opts
, current_language
);
1255 uiout
->field_stream ("value", stb
);
1258 /* This is the -data-read-memory command.
1260 ADDR: start address of data to be dumped.
1261 WORD-FORMAT: a char indicating format for the ``word''. See
1263 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
1264 NR_ROW: Number of rows.
1265 NR_COL: The number of colums (words per row).
1266 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
1267 ASCHAR for unprintable characters.
1269 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
1270 displayes them. Returns:
1272 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
1275 The number of bytes read is SIZE*ROW*COL. */
1278 mi_cmd_data_read_memory (const char *command
, char **argv
, int argc
)
1280 struct gdbarch
*gdbarch
= get_current_arch ();
1281 struct ui_out
*uiout
= current_uiout
;
1283 long total_bytes
, nr_cols
, nr_rows
;
1285 struct type
*word_type
;
1297 static const struct mi_opt opts
[] =
1299 {"o", OFFSET_OPT
, 1},
1305 int opt
= mi_getopt ("-data-read-memory", argc
, argv
, opts
,
1310 switch ((enum opt
) opt
)
1313 offset
= atol (oarg
);
1320 if (argc
< 5 || argc
> 6)
1321 error (_("-data-read-memory: Usage: "
1322 "ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR]."));
1324 /* Extract all the arguments. */
1326 /* Start address of the memory dump. */
1327 addr
= parse_and_eval_address (argv
[0]) + offset
;
1328 /* The format character to use when displaying a memory word. See
1329 the ``x'' command. */
1330 word_format
= argv
[1][0];
1331 /* The size of the memory word. */
1332 word_size
= atol (argv
[2]);
1336 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1340 word_type
= builtin_type (gdbarch
)->builtin_int16
;
1344 word_type
= builtin_type (gdbarch
)->builtin_int32
;
1348 word_type
= builtin_type (gdbarch
)->builtin_int64
;
1352 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1355 /* The number of rows. */
1356 nr_rows
= atol (argv
[3]);
1358 error (_("-data-read-memory: invalid number of rows."));
1360 /* Number of bytes per row. */
1361 nr_cols
= atol (argv
[4]);
1363 error (_("-data-read-memory: invalid number of columns."));
1365 /* The un-printable character when printing ascii. */
1371 /* Create a buffer and read it in. */
1372 total_bytes
= word_size
* nr_rows
* nr_cols
;
1374 gdb::byte_vector
mbuf (total_bytes
);
1376 /* Dispatch memory reads to the topmost target, not the flattened
1378 nr_bytes
= target_read (current_target
.beneath
,
1379 TARGET_OBJECT_MEMORY
, NULL
, mbuf
.data (),
1382 error (_("Unable to read memory."));
1384 /* Output the header information. */
1385 uiout
->field_core_addr ("addr", gdbarch
, addr
);
1386 uiout
->field_int ("nr-bytes", nr_bytes
);
1387 uiout
->field_int ("total-bytes", total_bytes
);
1388 uiout
->field_core_addr ("next-row", gdbarch
, addr
+ word_size
* nr_cols
);
1389 uiout
->field_core_addr ("prev-row", gdbarch
, addr
- word_size
* nr_cols
);
1390 uiout
->field_core_addr ("next-page", gdbarch
, addr
+ total_bytes
);
1391 uiout
->field_core_addr ("prev-page", gdbarch
, addr
- total_bytes
);
1393 /* Build the result as a two dimentional table. */
1400 ui_out_emit_list
list_emitter (uiout
, "memory");
1401 for (row
= 0, row_byte
= 0;
1403 row
++, row_byte
+= nr_cols
* word_size
)
1407 struct value_print_options opts
;
1409 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1410 uiout
->field_core_addr ("addr", gdbarch
, addr
+ row_byte
);
1411 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr +
1414 ui_out_emit_list
list_data_emitter (uiout
, "data");
1415 get_formatted_print_options (&opts
, word_format
);
1416 for (col
= 0, col_byte
= row_byte
;
1418 col
++, col_byte
+= word_size
)
1420 if (col_byte
+ word_size
> nr_bytes
)
1422 uiout
->field_string (NULL
, "N/A");
1427 print_scalar_formatted (&mbuf
[col_byte
], word_type
, &opts
,
1428 word_asize
, &stream
);
1429 uiout
->field_stream (NULL
, stream
);
1439 for (byte
= row_byte
;
1440 byte
< row_byte
+ word_size
* nr_cols
; byte
++)
1442 if (byte
>= nr_bytes
)
1444 else if (mbuf
[byte
] < 32 || mbuf
[byte
] > 126)
1445 stream
.putc (aschar
);
1447 stream
.putc (mbuf
[byte
]);
1449 uiout
->field_stream ("ascii", stream
);
1456 mi_cmd_data_read_memory_bytes (const char *command
, char **argv
, int argc
)
1458 struct gdbarch
*gdbarch
= get_current_arch ();
1459 struct ui_out
*uiout
= current_uiout
;
1463 int unit_size
= gdbarch_addressable_memory_unit_size (gdbarch
);
1470 static const struct mi_opt opts
[] =
1472 {"o", OFFSET_OPT
, 1},
1478 int opt
= mi_getopt ("-data-read-memory-bytes", argc
, argv
, opts
,
1482 switch ((enum opt
) opt
)
1485 offset
= atol (oarg
);
1493 error (_("Usage: [ -o OFFSET ] ADDR LENGTH."));
1495 addr
= parse_and_eval_address (argv
[0]) + offset
;
1496 length
= atol (argv
[1]);
1498 std::vector
<memory_read_result
> result
1499 = read_memory_robust (current_target
.beneath
, addr
, length
);
1501 if (result
.size () == 0)
1502 error (_("Unable to read memory."));
1504 ui_out_emit_list
list_emitter (uiout
, "memory");
1505 for (const memory_read_result
&read_result
: result
)
1507 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1509 uiout
->field_core_addr ("begin", gdbarch
, read_result
.begin
);
1510 uiout
->field_core_addr ("offset", gdbarch
, read_result
.begin
- addr
);
1511 uiout
->field_core_addr ("end", gdbarch
, read_result
.end
);
1513 std::string data
= bin2hex (read_result
.data
.get (),
1514 (read_result
.end
- read_result
.begin
)
1516 uiout
->field_string ("contents", data
.c_str ());
1520 /* Implementation of the -data-write_memory command.
1522 COLUMN_OFFSET: optional argument. Must be preceded by '-o'. The
1523 offset from the beginning of the memory grid row where the cell to
1525 ADDR: start address of the row in the memory grid where the memory
1526 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
1527 the location to write to.
1528 FORMAT: a char indicating format for the ``word''. See
1530 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
1531 VALUE: value to be written into the memory address.
1533 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1538 mi_cmd_data_write_memory (const char *command
, char **argv
, int argc
)
1540 struct gdbarch
*gdbarch
= get_current_arch ();
1541 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1544 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1545 enough when using a compiler other than GCC. */
1554 static const struct mi_opt opts
[] =
1556 {"o", OFFSET_OPT
, 1},
1562 int opt
= mi_getopt ("-data-write-memory", argc
, argv
, opts
,
1567 switch ((enum opt
) opt
)
1570 offset
= atol (oarg
);
1578 error (_("-data-write-memory: Usage: "
1579 "[-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE."));
1581 /* Extract all the arguments. */
1582 /* Start address of the memory dump. */
1583 addr
= parse_and_eval_address (argv
[0]);
1584 /* The size of the memory word. */
1585 word_size
= atol (argv
[2]);
1587 /* Calculate the real address of the write destination. */
1588 addr
+= (offset
* word_size
);
1590 /* Get the value as a number. */
1591 value
= parse_and_eval_address (argv
[3]);
1592 /* Get the value into an array. */
1593 gdb::byte_vector
buffer (word_size
);
1594 store_signed_integer (buffer
.data (), word_size
, byte_order
, value
);
1595 /* Write it down to memory. */
1596 write_memory_with_notification (addr
, buffer
.data (), word_size
);
1599 /* Implementation of the -data-write-memory-bytes command.
1602 DATA: string of bytes to write at that address
1603 COUNT: number of bytes to be filled (decimal integer). */
1606 mi_cmd_data_write_memory_bytes (const char *command
, char **argv
, int argc
)
1610 size_t len_hex
, len_bytes
, len_units
, i
, steps
, remaining_units
;
1611 long int count_units
;
1614 if (argc
!= 2 && argc
!= 3)
1615 error (_("Usage: ADDR DATA [COUNT]."));
1617 addr
= parse_and_eval_address (argv
[0]);
1619 len_hex
= strlen (cdata
);
1620 unit_size
= gdbarch_addressable_memory_unit_size (get_current_arch ());
1622 if (len_hex
% (unit_size
* 2) != 0)
1623 error (_("Hex-encoded '%s' must represent an integral number of "
1624 "addressable memory units."),
1627 len_bytes
= len_hex
/ 2;
1628 len_units
= len_bytes
/ unit_size
;
1631 count_units
= strtoul (argv
[2], NULL
, 10);
1633 count_units
= len_units
;
1635 gdb::byte_vector
databuf (len_bytes
);
1637 for (i
= 0; i
< len_bytes
; ++i
)
1640 if (sscanf (cdata
+ i
* 2, "%02x", &x
) != 1)
1641 error (_("Invalid argument"));
1642 databuf
[i
] = (gdb_byte
) x
;
1645 gdb::byte_vector data
;
1646 if (len_units
< count_units
)
1648 /* Pattern is made of less units than count:
1649 repeat pattern to fill memory. */
1650 data
= gdb::byte_vector (count_units
* unit_size
);
1652 /* Number of times the pattern is entirely repeated. */
1653 steps
= count_units
/ len_units
;
1654 /* Number of remaining addressable memory units. */
1655 remaining_units
= count_units
% len_units
;
1656 for (i
= 0; i
< steps
; i
++)
1657 memcpy (&data
[i
* len_bytes
], &databuf
[0], len_bytes
);
1659 if (remaining_units
> 0)
1660 memcpy (&data
[steps
* len_bytes
], &databuf
[0],
1661 remaining_units
* unit_size
);
1665 /* Pattern is longer than or equal to count:
1666 just copy count addressable memory units. */
1667 data
= std::move (databuf
);
1670 write_memory_with_notification (addr
, data
.data (), count_units
);
1674 mi_cmd_enable_timings (const char *command
, char **argv
, int argc
)
1680 if (strcmp (argv
[0], "yes") == 0)
1682 else if (strcmp (argv
[0], "no") == 0)
1693 error (_("-enable-timings: Usage: %s {yes|no}"), command
);
1697 mi_cmd_list_features (const char *command
, char **argv
, int argc
)
1701 struct ui_out
*uiout
= current_uiout
;
1703 ui_out_emit_list
list_emitter (uiout
, "features");
1704 uiout
->field_string (NULL
, "frozen-varobjs");
1705 uiout
->field_string (NULL
, "pending-breakpoints");
1706 uiout
->field_string (NULL
, "thread-info");
1707 uiout
->field_string (NULL
, "data-read-memory-bytes");
1708 uiout
->field_string (NULL
, "breakpoint-notifications");
1709 uiout
->field_string (NULL
, "ada-task-info");
1710 uiout
->field_string (NULL
, "language-option");
1711 uiout
->field_string (NULL
, "info-gdb-mi-command");
1712 uiout
->field_string (NULL
, "undefined-command-error-code");
1713 uiout
->field_string (NULL
, "exec-run-start-option");
1715 if (ext_lang_initialized_p (get_ext_lang_defn (EXT_LANG_PYTHON
)))
1716 uiout
->field_string (NULL
, "python");
1721 error (_("-list-features should be passed no arguments"));
1725 mi_cmd_list_target_features (const char *command
, char **argv
, int argc
)
1729 struct ui_out
*uiout
= current_uiout
;
1731 ui_out_emit_list
list_emitter (uiout
, "features");
1733 uiout
->field_string (NULL
, "async");
1734 if (target_can_execute_reverse
)
1735 uiout
->field_string (NULL
, "reverse");
1739 error (_("-list-target-features should be passed no arguments"));
1743 mi_cmd_add_inferior (const char *command
, char **argv
, int argc
)
1745 struct inferior
*inf
;
1748 error (_("-add-inferior should be passed no arguments"));
1750 inf
= add_inferior_with_spaces ();
1752 current_uiout
->field_fmt ("inferior", "i%d", inf
->num
);
1755 /* Callback used to find the first inferior other than the current
1759 get_other_inferior (struct inferior
*inf
, void *arg
)
1761 if (inf
== current_inferior ())
1768 mi_cmd_remove_inferior (const char *command
, char **argv
, int argc
)
1771 struct inferior
*inf
;
1774 error (_("-remove-inferior should be passed a single argument"));
1776 if (sscanf (argv
[0], "i%d", &id
) != 1)
1777 error (_("the thread group id is syntactically invalid"));
1779 inf
= find_inferior_id (id
);
1781 error (_("the specified thread group does not exist"));
1784 error (_("cannot remove an active inferior"));
1786 if (inf
== current_inferior ())
1788 struct thread_info
*tp
= 0;
1789 struct inferior
*new_inferior
1790 = iterate_over_inferiors (get_other_inferior
, NULL
);
1792 if (new_inferior
== NULL
)
1793 error (_("Cannot remove last inferior"));
1795 set_current_inferior (new_inferior
);
1796 if (new_inferior
->pid
!= 0)
1797 tp
= any_thread_of_process (new_inferior
->pid
);
1798 switch_to_thread (tp
? tp
->ptid
: null_ptid
);
1799 set_current_program_space (new_inferior
->pspace
);
1802 delete_inferior (inf
);
1807 /* Execute a command within a safe environment.
1808 Return <0 for error; >=0 for ok.
1810 args->action will tell mi_execute_command what action
1811 to perform after the given command has executed (display/suppress
1812 prompt, display error). */
1815 captured_mi_execute_command (struct ui_out
*uiout
, struct mi_parse
*context
)
1817 struct mi_interp
*mi
= (struct mi_interp
*) command_interp ();
1820 current_command_ts
= context
->cmd_start
;
1822 scoped_restore save_token
= make_scoped_restore (¤t_token
,
1825 running_result_record_printed
= 0;
1827 switch (context
->op
)
1830 /* A MI command was read from the input stream. */
1832 /* FIXME: gdb_???? */
1833 fprintf_unfiltered (mi
->raw_stdout
,
1834 " token=`%s' command=`%s' args=`%s'\n",
1835 context
->token
, context
->command
, context
->args
);
1837 mi_cmd_execute (context
);
1839 /* Print the result if there were no errors.
1841 Remember that on the way out of executing a command, you have
1842 to directly use the mi_interp's uiout, since the command
1843 could have reset the interpreter, in which case the current
1844 uiout will most likely crash in the mi_out_* routines. */
1845 if (!running_result_record_printed
)
1847 fputs_unfiltered (context
->token
, mi
->raw_stdout
);
1848 /* There's no particularly good reason why target-connect results
1849 in not ^done. Should kill ^connected for MI3. */
1850 fputs_unfiltered (strcmp (context
->command
, "target-select") == 0
1851 ? "^connected" : "^done", mi
->raw_stdout
);
1852 mi_out_put (uiout
, mi
->raw_stdout
);
1853 mi_out_rewind (uiout
);
1854 mi_print_timing_maybe (mi
->raw_stdout
);
1855 fputs_unfiltered ("\n", mi
->raw_stdout
);
1858 /* The command does not want anything to be printed. In that
1859 case, the command probably should not have written anything
1860 to uiout, but in case it has written something, discard it. */
1861 mi_out_rewind (uiout
);
1868 /* A CLI command was read from the input stream. */
1869 /* This "feature" will be removed as soon as we have a
1870 complete set of mi commands. */
1871 /* Echo the command on the console. */
1872 fprintf_unfiltered (gdb_stdlog
, "%s\n", context
->command
);
1873 /* Call the "console" interpreter. */
1874 argv
[0] = (char *) INTERP_CONSOLE
;
1875 argv
[1] = context
->command
;
1876 mi_cmd_interpreter_exec ("-interpreter-exec", argv
, 2);
1878 /* If we changed interpreters, DON'T print out anything. */
1879 if (current_interp_named_p (INTERP_MI
)
1880 || current_interp_named_p (INTERP_MI1
)
1881 || current_interp_named_p (INTERP_MI2
)
1882 || current_interp_named_p (INTERP_MI3
))
1884 if (!running_result_record_printed
)
1886 fputs_unfiltered (context
->token
, mi
->raw_stdout
);
1887 fputs_unfiltered ("^done", mi
->raw_stdout
);
1888 mi_out_put (uiout
, mi
->raw_stdout
);
1889 mi_out_rewind (uiout
);
1890 mi_print_timing_maybe (mi
->raw_stdout
);
1891 fputs_unfiltered ("\n", mi
->raw_stdout
);
1894 mi_out_rewind (uiout
);
1901 /* Print a gdb exception to the MI output stream. */
1904 mi_print_exception (const char *token
, struct gdb_exception exception
)
1906 struct mi_interp
*mi
= (struct mi_interp
*) current_interpreter ();
1908 fputs_unfiltered (token
, mi
->raw_stdout
);
1909 fputs_unfiltered ("^error,msg=\"", mi
->raw_stdout
);
1910 if (exception
.message
== NULL
)
1911 fputs_unfiltered ("unknown error", mi
->raw_stdout
);
1913 fputstr_unfiltered (exception
.message
, '"', mi
->raw_stdout
);
1914 fputs_unfiltered ("\"", mi
->raw_stdout
);
1916 switch (exception
.error
)
1918 case UNDEFINED_COMMAND_ERROR
:
1919 fputs_unfiltered (",code=\"undefined-command\"", mi
->raw_stdout
);
1923 fputs_unfiltered ("\n", mi
->raw_stdout
);
1926 /* Determine whether the parsed command already notifies the
1927 user_selected_context_changed observer. */
1930 command_notifies_uscc_observer (struct mi_parse
*command
)
1932 if (command
->op
== CLI_COMMAND
)
1934 /* CLI commands "thread" and "inferior" already send it. */
1935 return (strncmp (command
->command
, "thread ", 7) == 0
1936 || strncmp (command
->command
, "inferior ", 9) == 0);
1938 else /* MI_COMMAND */
1940 if (strcmp (command
->command
, "interpreter-exec") == 0
1941 && command
->argc
> 1)
1943 /* "thread" and "inferior" again, but through -interpreter-exec. */
1944 return (strncmp (command
->argv
[1], "thread ", 7) == 0
1945 || strncmp (command
->argv
[1], "inferior ", 9) == 0);
1949 /* -thread-select already sends it. */
1950 return strcmp (command
->command
, "thread-select") == 0;
1955 mi_execute_command (const char *cmd
, int from_tty
)
1958 std::unique_ptr
<struct mi_parse
> command
;
1960 /* This is to handle EOF (^D). We just quit gdb. */
1961 /* FIXME: we should call some API function here. */
1963 quit_force (NULL
, from_tty
);
1965 target_log_command (cmd
);
1969 command
= mi_parse (cmd
, &token
);
1971 CATCH (exception
, RETURN_MASK_ALL
)
1973 mi_print_exception (token
, exception
);
1978 if (command
!= NULL
)
1980 ptid_t previous_ptid
= inferior_ptid
;
1982 gdb::optional
<scoped_restore_tmpl
<int>> restore_suppress
;
1984 if (command
->cmd
!= NULL
&& command
->cmd
->suppress_notification
!= NULL
)
1985 restore_suppress
.emplace (command
->cmd
->suppress_notification
, 1);
1987 command
->token
= token
;
1991 command
->cmd_start
= new mi_timestamp ();
1992 timestamp (command
->cmd_start
);
1997 captured_mi_execute_command (current_uiout
, command
.get ());
1999 CATCH (result
, RETURN_MASK_ALL
)
2001 /* Like in start_event_loop, enable input and force display
2002 of the prompt. Otherwise, any command that calls
2003 async_disable_stdin, and then throws, will leave input
2005 async_enable_stdin ();
2006 current_ui
->prompt_state
= PROMPT_NEEDED
;
2008 /* The command execution failed and error() was called
2010 mi_print_exception (command
->token
, result
);
2011 mi_out_rewind (current_uiout
);
2015 bpstat_do_actions ();
2017 if (/* The notifications are only output when the top-level
2018 interpreter (specified on the command line) is MI. */
2019 interp_ui_out (top_level_interpreter ())->is_mi_like_p ()
2020 /* Don't try report anything if there are no threads --
2021 the program is dead. */
2022 && thread_count () != 0
2023 /* If the command already reports the thread change, no need to do it
2025 && !command_notifies_uscc_observer (command
.get ()))
2027 struct mi_interp
*mi
= (struct mi_interp
*) top_level_interpreter ();
2028 int report_change
= 0;
2030 if (command
->thread
== -1)
2032 report_change
= (!ptid_equal (previous_ptid
, null_ptid
)
2033 && !ptid_equal (inferior_ptid
, previous_ptid
)
2034 && !ptid_equal (inferior_ptid
, null_ptid
));
2036 else if (!ptid_equal (inferior_ptid
, null_ptid
))
2038 struct thread_info
*ti
= inferior_thread ();
2040 report_change
= (ti
->global_num
!= command
->thread
);
2045 observer_notify_user_selected_context_changed
2046 (USER_SELECTED_THREAD
| USER_SELECTED_FRAME
);
2053 mi_cmd_execute (struct mi_parse
*parse
)
2055 scoped_value_mark cleanup
= prepare_execute_command ();
2057 if (parse
->all
&& parse
->thread_group
!= -1)
2058 error (_("Cannot specify --thread-group together with --all"));
2060 if (parse
->all
&& parse
->thread
!= -1)
2061 error (_("Cannot specify --thread together with --all"));
2063 if (parse
->thread_group
!= -1 && parse
->thread
!= -1)
2064 error (_("Cannot specify --thread together with --thread-group"));
2066 if (parse
->frame
!= -1 && parse
->thread
== -1)
2067 error (_("Cannot specify --frame without --thread"));
2069 if (parse
->thread_group
!= -1)
2071 struct inferior
*inf
= find_inferior_id (parse
->thread_group
);
2072 struct thread_info
*tp
= 0;
2075 error (_("Invalid thread group for the --thread-group option"));
2077 set_current_inferior (inf
);
2078 /* This behaviour means that if --thread-group option identifies
2079 an inferior with multiple threads, then a random one will be
2080 picked. This is not a problem -- frontend should always
2081 provide --thread if it wishes to operate on a specific
2084 tp
= any_live_thread_of_process (inf
->pid
);
2085 switch_to_thread (tp
? tp
->ptid
: null_ptid
);
2086 set_current_program_space (inf
->pspace
);
2089 if (parse
->thread
!= -1)
2091 struct thread_info
*tp
= find_thread_global_id (parse
->thread
);
2094 error (_("Invalid thread id: %d"), parse
->thread
);
2096 if (is_exited (tp
->ptid
))
2097 error (_("Thread id: %d has terminated"), parse
->thread
);
2099 switch_to_thread (tp
->ptid
);
2102 if (parse
->frame
!= -1)
2104 struct frame_info
*fid
;
2105 int frame
= parse
->frame
;
2107 fid
= find_relative_frame (get_current_frame (), &frame
);
2109 /* find_relative_frame was successful */
2112 error (_("Invalid frame id: %d"), frame
);
2115 gdb::optional
<scoped_restore_current_language
> lang_saver
;
2116 if (parse
->language
!= language_unknown
)
2118 lang_saver
.emplace ();
2119 set_language (parse
->language
);
2122 current_context
= parse
;
2124 if (parse
->cmd
->argv_func
!= NULL
)
2126 parse
->cmd
->argv_func (parse
->command
, parse
->argv
, parse
->argc
);
2128 else if (parse
->cmd
->cli
.cmd
!= 0)
2130 /* FIXME: DELETE THIS. */
2131 /* The operation is still implemented by a cli command. */
2132 /* Must be a synchronous one. */
2133 mi_execute_cli_command (parse
->cmd
->cli
.cmd
, parse
->cmd
->cli
.args_p
,
2138 /* FIXME: DELETE THIS. */
2141 stb
.puts ("Undefined mi command: ");
2142 stb
.putstr (parse
->command
, '"');
2143 stb
.puts (" (missing implementation)");
2149 /* FIXME: This is just a hack so we can get some extra commands going.
2150 We don't want to channel things through the CLI, but call libgdb directly.
2151 Use only for synchronous commands. */
2154 mi_execute_cli_command (const char *cmd
, int args_p
, const char *args
)
2158 std::string run
= cmd
;
2161 run
= run
+ " " + args
;
2163 /* FIXME: gdb_???? */
2164 fprintf_unfiltered (gdb_stdout
, "cli=%s run=%s\n",
2166 execute_command (run
.c_str (), 0 /* from_tty */ );
2171 mi_execute_async_cli_command (const char *cli_command
, char **argv
, int argc
)
2173 std::string run
= cli_command
;
2176 run
= run
+ " " + *argv
;
2180 execute_command (run
.c_str (), 0 /* from_tty */ );
2184 mi_load_progress (const char *section_name
,
2185 unsigned long sent_so_far
,
2186 unsigned long total_section
,
2187 unsigned long total_sent
,
2188 unsigned long grand_total
)
2190 using namespace std::chrono
;
2191 static steady_clock::time_point last_update
;
2192 static char *previous_sect_name
= NULL
;
2194 struct mi_interp
*mi
= (struct mi_interp
*) current_interpreter ();
2196 /* This function is called through deprecated_show_load_progress
2197 which means uiout may not be correct. Fix it for the duration
2198 of this function. */
2200 std::unique_ptr
<ui_out
> uiout
;
2202 if (current_interp_named_p (INTERP_MI
)
2203 || current_interp_named_p (INTERP_MI2
))
2204 uiout
.reset (mi_out_new (2));
2205 else if (current_interp_named_p (INTERP_MI1
))
2206 uiout
.reset (mi_out_new (1));
2207 else if (current_interp_named_p (INTERP_MI3
))
2208 uiout
.reset (mi_out_new (3));
2212 scoped_restore save_uiout
2213 = make_scoped_restore (¤t_uiout
, uiout
.get ());
2215 new_section
= (previous_sect_name
?
2216 strcmp (previous_sect_name
, section_name
) : 1);
2219 xfree (previous_sect_name
);
2220 previous_sect_name
= xstrdup (section_name
);
2223 fputs_unfiltered (current_token
, mi
->raw_stdout
);
2224 fputs_unfiltered ("+download", mi
->raw_stdout
);
2226 ui_out_emit_tuple
tuple_emitter (uiout
.get (), NULL
);
2227 uiout
->field_string ("section", section_name
);
2228 uiout
->field_int ("section-size", total_section
);
2229 uiout
->field_int ("total-size", grand_total
);
2231 mi_out_put (uiout
.get (), mi
->raw_stdout
);
2232 fputs_unfiltered ("\n", mi
->raw_stdout
);
2233 gdb_flush (mi
->raw_stdout
);
2236 steady_clock::time_point time_now
= steady_clock::now ();
2237 if (time_now
- last_update
> milliseconds (500))
2239 last_update
= time_now
;
2241 fputs_unfiltered (current_token
, mi
->raw_stdout
);
2242 fputs_unfiltered ("+download", mi
->raw_stdout
);
2244 ui_out_emit_tuple
tuple_emitter (uiout
.get (), NULL
);
2245 uiout
->field_string ("section", section_name
);
2246 uiout
->field_int ("section-sent", sent_so_far
);
2247 uiout
->field_int ("section-size", total_section
);
2248 uiout
->field_int ("total-sent", total_sent
);
2249 uiout
->field_int ("total-size", grand_total
);
2251 mi_out_put (uiout
.get (), mi
->raw_stdout
);
2252 fputs_unfiltered ("\n", mi
->raw_stdout
);
2253 gdb_flush (mi
->raw_stdout
);
2258 timestamp (struct mi_timestamp
*tv
)
2260 using namespace std::chrono
;
2262 tv
->wallclock
= steady_clock::now ();
2263 run_time_clock::now (tv
->utime
, tv
->stime
);
2267 print_diff_now (struct ui_file
*file
, struct mi_timestamp
*start
)
2269 struct mi_timestamp now
;
2272 print_diff (file
, start
, &now
);
2276 mi_print_timing_maybe (struct ui_file
*file
)
2278 /* If the command is -enable-timing then do_timings may be true
2279 whilst current_command_ts is not initialized. */
2280 if (do_timings
&& current_command_ts
)
2281 print_diff_now (file
, current_command_ts
);
2285 print_diff (struct ui_file
*file
, struct mi_timestamp
*start
,
2286 struct mi_timestamp
*end
)
2288 using namespace std::chrono
;
2290 duration
<double> wallclock
= end
->wallclock
- start
->wallclock
;
2291 duration
<double> utime
= end
->utime
- start
->utime
;
2292 duration
<double> stime
= end
->stime
- start
->stime
;
2296 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
2297 wallclock
.count (), utime
.count (), stime
.count ());
2301 mi_cmd_trace_define_variable (const char *command
, char **argv
, int argc
)
2303 LONGEST initval
= 0;
2304 struct trace_state_variable
*tsv
;
2307 if (argc
!= 1 && argc
!= 2)
2308 error (_("Usage: -trace-define-variable VARIABLE [VALUE]"));
2312 error (_("Name of trace variable should start with '$'"));
2314 validate_trace_state_variable_name (name
);
2316 tsv
= find_trace_state_variable (name
);
2318 tsv
= create_trace_state_variable (name
);
2321 initval
= value_as_long (parse_and_eval (argv
[1]));
2323 tsv
->initial_value
= initval
;
2327 mi_cmd_trace_list_variables (const char *command
, char **argv
, int argc
)
2330 error (_("-trace-list-variables: no arguments allowed"));
2332 tvariables_info_1 ();
2336 mi_cmd_trace_find (const char *command
, char **argv
, int argc
)
2341 error (_("trace selection mode is required"));
2345 if (strcmp (mode
, "none") == 0)
2347 tfind_1 (tfind_number
, -1, 0, 0, 0);
2351 check_trace_running (current_trace_status ());
2353 if (strcmp (mode
, "frame-number") == 0)
2356 error (_("frame number is required"));
2357 tfind_1 (tfind_number
, atoi (argv
[1]), 0, 0, 0);
2359 else if (strcmp (mode
, "tracepoint-number") == 0)
2362 error (_("tracepoint number is required"));
2363 tfind_1 (tfind_tp
, atoi (argv
[1]), 0, 0, 0);
2365 else if (strcmp (mode
, "pc") == 0)
2368 error (_("PC is required"));
2369 tfind_1 (tfind_pc
, 0, parse_and_eval_address (argv
[1]), 0, 0);
2371 else if (strcmp (mode
, "pc-inside-range") == 0)
2374 error (_("Start and end PC are required"));
2375 tfind_1 (tfind_range
, 0, parse_and_eval_address (argv
[1]),
2376 parse_and_eval_address (argv
[2]), 0);
2378 else if (strcmp (mode
, "pc-outside-range") == 0)
2381 error (_("Start and end PC are required"));
2382 tfind_1 (tfind_outside
, 0, parse_and_eval_address (argv
[1]),
2383 parse_and_eval_address (argv
[2]), 0);
2385 else if (strcmp (mode
, "line") == 0)
2388 error (_("Line is required"));
2390 std::vector
<symtab_and_line
> sals
2391 = decode_line_with_current_source (argv
[1],
2392 DECODE_LINE_FUNFIRSTLINE
);
2393 const symtab_and_line
&sal
= sals
[0];
2395 if (sal
.symtab
== 0)
2396 error (_("Could not find the specified line"));
2398 CORE_ADDR start_pc
, end_pc
;
2399 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2400 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, 0);
2402 error (_("Could not find the specified line"));
2405 error (_("Invalid mode '%s'"), mode
);
2407 if (has_stack_frames () || get_traceframe_number () >= 0)
2408 print_stack_frame (get_selected_frame (NULL
), 1, LOC_AND_ADDRESS
, 1);
2412 mi_cmd_trace_save (const char *command
, char **argv
, int argc
)
2414 int target_saves
= 0;
2415 int generate_ctf
= 0;
2422 TARGET_SAVE_OPT
, CTF_OPT
2424 static const struct mi_opt opts
[] =
2426 {"r", TARGET_SAVE_OPT
, 0},
2427 {"ctf", CTF_OPT
, 0},
2433 int opt
= mi_getopt ("-trace-save", argc
, argv
, opts
,
2438 switch ((enum opt
) opt
)
2440 case TARGET_SAVE_OPT
:
2449 if (argc
- oind
!= 1)
2450 error (_("Exactly one argument required "
2451 "(file in which to save trace data)"));
2453 filename
= argv
[oind
];
2456 trace_save_ctf (filename
, target_saves
);
2458 trace_save_tfile (filename
, target_saves
);
2462 mi_cmd_trace_start (const char *command
, char **argv
, int argc
)
2464 start_tracing (NULL
);
2468 mi_cmd_trace_status (const char *command
, char **argv
, int argc
)
2470 trace_status_mi (0);
2474 mi_cmd_trace_stop (const char *command
, char **argv
, int argc
)
2476 stop_tracing (NULL
);
2477 trace_status_mi (1);
2480 /* Implement the "-ada-task-info" command. */
2483 mi_cmd_ada_task_info (const char *command
, char **argv
, int argc
)
2485 if (argc
!= 0 && argc
!= 1)
2486 error (_("Invalid MI command"));
2488 print_ada_task_info (current_uiout
, argv
[0], current_inferior ());
2491 /* Print EXPRESSION according to VALUES. */
2494 print_variable_or_computed (const char *expression
, enum print_values values
)
2498 struct ui_out
*uiout
= current_uiout
;
2502 expression_up expr
= parse_expression (expression
);
2504 if (values
== PRINT_SIMPLE_VALUES
)
2505 val
= evaluate_type (expr
.get ());
2507 val
= evaluate_expression (expr
.get ());
2509 gdb::optional
<ui_out_emit_tuple
> tuple_emitter
;
2510 if (values
!= PRINT_NO_VALUES
)
2511 tuple_emitter
.emplace (uiout
, nullptr);
2512 uiout
->field_string ("name", expression
);
2516 case PRINT_SIMPLE_VALUES
:
2517 type
= check_typedef (value_type (val
));
2518 type_print (value_type (val
), "", &stb
, -1);
2519 uiout
->field_stream ("type", stb
);
2520 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
2521 && TYPE_CODE (type
) != TYPE_CODE_STRUCT
2522 && TYPE_CODE (type
) != TYPE_CODE_UNION
)
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
);
2532 case PRINT_ALL_VALUES
:
2534 struct value_print_options opts
;
2536 get_no_prettyformat_print_options (&opts
);
2538 common_val_print (val
, &stb
, 0, &opts
, current_language
);
2539 uiout
->field_stream ("value", stb
);
2545 /* Implement the "-trace-frame-collected" command. */
2548 mi_cmd_trace_frame_collected (const char *command
, char **argv
, int argc
)
2550 struct bp_location
*tloc
;
2552 struct collection_list
*clist
;
2553 struct collection_list tracepoint_list
, stepping_list
;
2554 struct traceframe_info
*tinfo
;
2556 enum print_values var_print_values
= PRINT_ALL_VALUES
;
2557 enum print_values comp_print_values
= PRINT_ALL_VALUES
;
2558 int registers_format
= 'x';
2559 int memory_contents
= 0;
2560 struct ui_out
*uiout
= current_uiout
;
2568 static const struct mi_opt opts
[] =
2570 {"-var-print-values", VAR_PRINT_VALUES
, 1},
2571 {"-comp-print-values", COMP_PRINT_VALUES
, 1},
2572 {"-registers-format", REGISTERS_FORMAT
, 1},
2573 {"-memory-contents", MEMORY_CONTENTS
, 0},
2580 int opt
= mi_getopt ("-trace-frame-collected", argc
, argv
, opts
,
2584 switch ((enum opt
) opt
)
2586 case VAR_PRINT_VALUES
:
2587 var_print_values
= mi_parse_print_values (oarg
);
2589 case COMP_PRINT_VALUES
:
2590 comp_print_values
= mi_parse_print_values (oarg
);
2592 case REGISTERS_FORMAT
:
2593 registers_format
= oarg
[0];
2594 case MEMORY_CONTENTS
:
2595 memory_contents
= 1;
2601 error (_("Usage: -trace-frame-collected "
2602 "[--var-print-values PRINT_VALUES] "
2603 "[--comp-print-values PRINT_VALUES] "
2604 "[--registers-format FORMAT]"
2605 "[--memory-contents]"));
2607 /* This throws an error is not inspecting a trace frame. */
2608 tloc
= get_traceframe_location (&stepping_frame
);
2610 /* This command only makes sense for the current frame, not the
2612 scoped_restore_current_thread restore_thread
;
2613 select_frame (get_current_frame ());
2615 encode_actions (tloc
, &tracepoint_list
, &stepping_list
);
2618 clist
= &stepping_list
;
2620 clist
= &tracepoint_list
;
2622 tinfo
= get_traceframe_info ();
2624 /* Explicitly wholly collected variables. */
2628 ui_out_emit_list
list_emitter (uiout
, "explicit-variables");
2629 const std::vector
<std::string
> &wholly_collected
2630 = clist
->wholly_collected ();
2631 for (size_t i
= 0; i
< wholly_collected
.size (); i
++)
2633 const std::string
&str
= wholly_collected
[i
];
2634 print_variable_or_computed (str
.c_str (), var_print_values
);
2638 /* Computed expressions. */
2643 ui_out_emit_list
list_emitter (uiout
, "computed-expressions");
2645 const std::vector
<std::string
> &computed
= clist
->computed ();
2646 for (size_t i
= 0; i
< computed
.size (); i
++)
2648 const std::string
&str
= computed
[i
];
2649 print_variable_or_computed (str
.c_str (), comp_print_values
);
2653 /* Registers. Given pseudo-registers, and that some architectures
2654 (like MIPS) actually hide the raw registers, we don't go through
2655 the trace frame info, but instead consult the register cache for
2656 register availability. */
2658 struct frame_info
*frame
;
2659 struct gdbarch
*gdbarch
;
2663 ui_out_emit_list
list_emitter (uiout
, "registers");
2665 frame
= get_selected_frame (NULL
);
2666 gdbarch
= get_frame_arch (frame
);
2667 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
2669 for (regnum
= 0; regnum
< numregs
; regnum
++)
2671 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
2672 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
2675 output_register (frame
, regnum
, registers_format
, 1);
2679 /* Trace state variables. */
2681 ui_out_emit_list
list_emitter (uiout
, "tvars");
2683 for (int tvar
: tinfo
->tvars
)
2685 struct trace_state_variable
*tsv
;
2687 tsv
= find_trace_state_variable_by_number (tvar
);
2689 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
2693 uiout
->field_fmt ("name", "$%s", tsv
->name
);
2695 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
2697 uiout
->field_int ("current", tsv
->value
);
2701 uiout
->field_skip ("name");
2702 uiout
->field_skip ("current");
2709 std::vector
<mem_range
> available_memory
;
2711 traceframe_available_memory (&available_memory
, 0, ULONGEST_MAX
);
2713 ui_out_emit_list
list_emitter (uiout
, "memory");
2715 for (const mem_range
&r
: available_memory
)
2717 struct gdbarch
*gdbarch
= target_gdbarch ();
2719 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
2721 uiout
->field_core_addr ("address", gdbarch
, r
.start
);
2722 uiout
->field_int ("length", r
.length
);
2724 gdb::byte_vector
data (r
.length
);
2726 if (memory_contents
)
2728 if (target_read_memory (r
.start
, data
.data (), r
.length
) == 0)
2730 std::string data_str
= bin2hex (data
.data (), r
.length
);
2731 uiout
->field_string ("contents", data_str
.c_str ());
2734 uiout
->field_skip ("contents");
2741 _initialize_mi_main (void)
2743 struct cmd_list_element
*c
;
2745 add_setshow_boolean_cmd ("mi-async", class_run
,
2747 Set whether MI asynchronous mode is enabled."), _("\
2748 Show whether MI asynchronous mode is enabled."), _("\
2749 Tells GDB whether MI should be in asynchronous mode."),
2750 set_mi_async_command
,
2751 show_mi_async_command
,
2755 /* Alias old "target-async" to "mi-async". */
2756 c
= add_alias_cmd ("target-async", "mi-async", class_run
, 0, &setlist
);
2757 deprecate_cmd (c
, "set mi-async");
2758 c
= add_alias_cmd ("target-async", "mi-async", class_run
, 0, &showlist
);
2759 deprecate_cmd (c
, "show mi-async");