3 Copyright (C) 2000-2017 Free Software Foundation, Inc.
5 Contributed by Cygnus Solutions (a Red Hat company).
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "arch-utils.h"
28 #include "gdbthread.h"
31 #include "mi-getopt.h"
32 #include "mi-console.h"
36 #include "event-loop.h"
37 #include "event-top.h"
38 #include "gdbcore.h" /* For write_memory(). */
44 #include "mi-common.h"
49 #include "splay-tree.h"
50 #include "tracepoint.h"
54 #include "extension.h"
57 #include "common/gdb_optional.h"
58 #include "common/byte-vector.h"
61 #include "run-time-clock.h"
63 #include "progspace-and-thread.h"
64 #include "common/rsp-low.h"
73 /* This is used to pass the current command timestamp down to
74 continuation routines. */
75 static struct mi_timestamp
*current_command_ts
;
77 static int do_timings
= 0;
80 /* Few commands would like to know if options like --thread-group were
81 explicitly specified. This variable keeps the current parsed
82 command including all option, and make it possible. */
83 static struct mi_parse
*current_context
;
85 int running_result_record_printed
= 1;
87 /* Flag indicating that the target has proceeded since the last
88 command was issued. */
91 static void mi_cmd_execute (struct mi_parse
*parse
);
93 static void mi_execute_cli_command (const char *cmd
, int args_p
,
95 static void mi_execute_async_cli_command (const char *cli_command
,
96 char **argv
, int argc
);
97 static int register_changed_p (int regnum
, struct regcache
*,
99 static void output_register (struct frame_info
*, int regnum
, int format
,
100 int skip_unavailable
);
102 /* Controls whether the frontend wants MI in async mode. */
103 static int mi_async
= 0;
105 /* The set command writes to this variable. If the inferior is
106 executing, mi_async is *not* updated. */
107 static int mi_async_1
= 0;
110 set_mi_async_command (char *args
, int from_tty
,
111 struct cmd_list_element
*c
)
113 if (have_live_inferiors ())
115 mi_async_1
= mi_async
;
116 error (_("Cannot change this setting while the inferior is running."));
119 mi_async
= mi_async_1
;
123 show_mi_async_command (struct ui_file
*file
, int from_tty
,
124 struct cmd_list_element
*c
,
127 fprintf_filtered (file
,
128 _("Whether MI is in asynchronous mode is %s.\n"),
132 /* A wrapper for target_can_async_p that takes the MI setting into
138 return mi_async
&& target_can_async_p ();
141 /* Command implementations. FIXME: Is this libgdb? No. This is the MI
142 layer that calls libgdb. Any operation used in the below should be
145 static void timestamp (struct mi_timestamp
*tv
);
147 static void print_diff (struct ui_file
*file
, struct mi_timestamp
*start
,
148 struct mi_timestamp
*end
);
151 mi_cmd_gdb_exit (const char *command
, char **argv
, int argc
)
153 struct mi_interp
*mi
= (struct mi_interp
*) current_interpreter ();
155 /* We have to print everything right here because we never return. */
157 fputs_unfiltered (current_token
, mi
->raw_stdout
);
158 fputs_unfiltered ("^exit\n", mi
->raw_stdout
);
159 mi_out_put (current_uiout
, mi
->raw_stdout
);
160 gdb_flush (mi
->raw_stdout
);
161 /* FIXME: The function called is not yet a formal libgdb function. */
162 quit_force (NULL
, FROM_TTY
);
166 mi_cmd_exec_next (const char *command
, char **argv
, int argc
)
168 /* FIXME: Should call a libgdb function, not a cli wrapper. */
169 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
170 mi_execute_async_cli_command ("reverse-next", argv
+ 1, argc
- 1);
172 mi_execute_async_cli_command ("next", argv
, argc
);
176 mi_cmd_exec_next_instruction (const char *command
, char **argv
, int argc
)
178 /* FIXME: Should call a libgdb function, not a cli wrapper. */
179 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
180 mi_execute_async_cli_command ("reverse-nexti", argv
+ 1, argc
- 1);
182 mi_execute_async_cli_command ("nexti", argv
, argc
);
186 mi_cmd_exec_step (const char *command
, char **argv
, int argc
)
188 /* FIXME: Should call a libgdb function, not a cli wrapper. */
189 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
190 mi_execute_async_cli_command ("reverse-step", argv
+ 1, argc
- 1);
192 mi_execute_async_cli_command ("step", argv
, argc
);
196 mi_cmd_exec_step_instruction (const char *command
, char **argv
, int argc
)
198 /* FIXME: Should call a libgdb function, not a cli wrapper. */
199 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
200 mi_execute_async_cli_command ("reverse-stepi", argv
+ 1, argc
- 1);
202 mi_execute_async_cli_command ("stepi", argv
, argc
);
206 mi_cmd_exec_finish (const char *command
, char **argv
, int argc
)
208 /* FIXME: Should call a libgdb function, not a cli wrapper. */
209 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
210 mi_execute_async_cli_command ("reverse-finish", argv
+ 1, argc
- 1);
212 mi_execute_async_cli_command ("finish", argv
, argc
);
216 mi_cmd_exec_return (const char *command
, char **argv
, int argc
)
218 /* This command doesn't really execute the target, it just pops the
219 specified number of frames. */
221 /* Call return_command with from_tty argument equal to 0 so as to
222 avoid being queried. */
223 return_command (*argv
, 0);
225 /* Call return_command with from_tty argument equal to 0 so as to
226 avoid being queried. */
227 return_command (NULL
, 0);
229 /* Because we have called return_command with from_tty = 0, we need
230 to print the frame here. */
231 print_stack_frame (get_selected_frame (NULL
), 1, LOC_AND_ADDRESS
, 1);
235 mi_cmd_exec_jump (const char *args
, char **argv
, int argc
)
237 /* FIXME: Should call a libgdb function, not a cli wrapper. */
238 mi_execute_async_cli_command ("jump", argv
, argc
);
242 proceed_thread (struct thread_info
*thread
, int pid
)
244 if (!is_stopped (thread
->ptid
))
247 if (pid
!= 0 && ptid_get_pid (thread
->ptid
) != pid
)
250 switch_to_thread (thread
->ptid
);
251 clear_proceed_status (0);
252 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
);
256 proceed_thread_callback (struct thread_info
*thread
, void *arg
)
258 int pid
= *(int *)arg
;
260 proceed_thread (thread
, pid
);
265 exec_continue (char **argv
, int argc
)
267 prepare_execution_command (¤t_target
, mi_async_p ());
271 /* In non-stop mode, 'resume' always resumes a single thread.
272 Therefore, to resume all threads of the current inferior, or
273 all threads in all inferiors, we need to iterate over
276 See comment on infcmd.c:proceed_thread_callback for rationale. */
277 if (current_context
->all
|| current_context
->thread_group
!= -1)
279 scoped_restore_current_thread restore_thread
;
282 if (!current_context
->all
)
285 = find_inferior_id (current_context
->thread_group
);
289 iterate_over_threads (proceed_thread_callback
, &pid
);
298 scoped_restore save_multi
= make_scoped_restore (&sched_multi
);
300 if (current_context
->all
)
307 /* In all-stop mode, -exec-continue traditionally resumed
308 either all threads, or one thread, depending on the
309 'scheduler-locking' variable. Let's continue to do the
317 exec_reverse_continue (char **argv
, int argc
)
319 enum exec_direction_kind dir
= execution_direction
;
321 if (dir
== EXEC_REVERSE
)
322 error (_("Already in reverse mode."));
324 if (!target_can_execute_reverse
)
325 error (_("Target %s does not support this command."), target_shortname
);
327 scoped_restore save_exec_dir
= make_scoped_restore (&execution_direction
,
329 exec_continue (argv
, argc
);
333 mi_cmd_exec_continue (const char *command
, char **argv
, int argc
)
335 if (argc
> 0 && strcmp (argv
[0], "--reverse") == 0)
336 exec_reverse_continue (argv
+ 1, argc
- 1);
338 exec_continue (argv
, argc
);
342 interrupt_thread_callback (struct thread_info
*thread
, void *arg
)
344 int pid
= *(int *)arg
;
346 if (!is_running (thread
->ptid
))
349 if (ptid_get_pid (thread
->ptid
) != pid
)
352 target_stop (thread
->ptid
);
356 /* Interrupt the execution of the target. Note how we must play
357 around with the token variables, in order to display the current
358 token in the result of the interrupt command, and the previous
359 execution token when the target finally stops. See comments in
363 mi_cmd_exec_interrupt (const char *command
, char **argv
, int argc
)
365 /* In all-stop mode, everything stops, so we don't need to try
366 anything specific. */
369 interrupt_target_1 (0);
373 if (current_context
->all
)
375 /* This will interrupt all threads in all inferiors. */
376 interrupt_target_1 (1);
378 else if (current_context
->thread_group
!= -1)
380 struct inferior
*inf
= find_inferior_id (current_context
->thread_group
);
382 iterate_over_threads (interrupt_thread_callback
, &inf
->pid
);
386 /* Interrupt just the current thread -- either explicitly
387 specified via --thread or whatever was current before
388 MI command was sent. */
389 interrupt_target_1 (0);
393 /* Callback for iterate_over_inferiors which starts the execution
394 of the given inferior.
396 ARG is a pointer to an integer whose value, if non-zero, indicates
397 that the program should be stopped when reaching the main subprogram
398 (similar to what the CLI "start" command does). */
401 run_one_inferior (struct inferior
*inf
, void *arg
)
403 int start_p
= *(int *) arg
;
404 const char *run_cmd
= start_p
? "start" : "run";
405 struct target_ops
*run_target
= find_run_target ();
406 int async_p
= mi_async
&& run_target
->to_can_async_p (run_target
);
410 if (inf
->pid
!= ptid_get_pid (inferior_ptid
))
412 struct thread_info
*tp
;
414 tp
= any_thread_of_process (inf
->pid
);
416 error (_("Inferior has no threads."));
418 switch_to_thread (tp
->ptid
);
423 set_current_inferior (inf
);
424 switch_to_thread (null_ptid
);
425 set_current_program_space (inf
->pspace
);
427 mi_execute_cli_command (run_cmd
, async_p
,
428 async_p
? "&" : NULL
);
433 mi_cmd_exec_run (const char *command
, char **argv
, int argc
)
437 /* Parse the command options. */
442 static const struct mi_opt opts
[] =
444 {"-start", START_OPT
, 0},
453 int opt
= mi_getopt ("-exec-run", argc
, argv
, opts
, &oind
, &oarg
);
457 switch ((enum opt
) opt
)
465 /* This command does not accept any argument. Make sure the user
466 did not provide any. */
468 error (_("Invalid argument: %s"), argv
[oind
]);
470 if (current_context
->all
)
472 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
474 iterate_over_inferiors (run_one_inferior
, &start_p
);
478 const char *run_cmd
= start_p
? "start" : "run";
479 struct target_ops
*run_target
= find_run_target ();
480 int async_p
= mi_async
&& run_target
->to_can_async_p (run_target
);
482 mi_execute_cli_command (run_cmd
, async_p
,
483 async_p
? "&" : NULL
);
489 find_thread_of_process (struct thread_info
*ti
, void *p
)
493 if (ptid_get_pid (ti
->ptid
) == pid
&& !is_exited (ti
->ptid
))
500 mi_cmd_target_detach (const char *command
, char **argv
, int argc
)
502 if (argc
!= 0 && argc
!= 1)
503 error (_("Usage: -target-detach [pid | thread-group]"));
507 struct thread_info
*tp
;
511 /* First see if we are dealing with a thread-group id. */
514 struct inferior
*inf
;
515 int id
= strtoul (argv
[0] + 1, &end
, 0);
518 error (_("Invalid syntax of thread-group id '%s'"), argv
[0]);
520 inf
= find_inferior_id (id
);
522 error (_("Non-existent thread-group id '%d'"), id
);
528 /* We must be dealing with a pid. */
529 pid
= strtol (argv
[0], &end
, 10);
532 error (_("Invalid identifier '%s'"), argv
[0]);
535 /* Pick any thread in the desired process. Current
536 target_detach detaches from the parent of inferior_ptid. */
537 tp
= iterate_over_threads (find_thread_of_process
, &pid
);
539 error (_("Thread group is empty"));
541 switch_to_thread (tp
->ptid
);
544 detach_command (NULL
, 0);
548 mi_cmd_target_flash_erase (const char *command
, char **argv
, int argc
)
550 flash_erase_command (NULL
, 0);
554 mi_cmd_thread_select (const char *command
, char **argv
, int argc
)
557 char *mi_error_message
;
558 ptid_t previous_ptid
= inferior_ptid
;
561 error (_("-thread-select: USAGE: threadnum."));
563 rc
= gdb_thread_select (current_uiout
, argv
[0], &mi_error_message
);
565 /* If thread switch did not succeed don't notify or print. */
566 if (rc
== GDB_RC_FAIL
)
568 make_cleanup (xfree
, mi_error_message
);
569 error ("%s", mi_error_message
);
572 print_selected_thread_frame (current_uiout
,
573 USER_SELECTED_THREAD
| USER_SELECTED_FRAME
);
575 /* Notify if the thread has effectively changed. */
576 if (!ptid_equal (inferior_ptid
, previous_ptid
))
578 observer_notify_user_selected_context_changed (USER_SELECTED_THREAD
579 | USER_SELECTED_FRAME
);
584 mi_cmd_thread_list_ids (const char *command
, char **argv
, int argc
)
587 char *mi_error_message
;
590 error (_("-thread-list-ids: No arguments required."));
592 rc
= gdb_list_thread_ids (current_uiout
, &mi_error_message
);
594 if (rc
== GDB_RC_FAIL
)
596 make_cleanup (xfree
, mi_error_message
);
597 error ("%s", mi_error_message
);
602 mi_cmd_thread_info (const char *command
, char **argv
, int argc
)
604 if (argc
!= 0 && argc
!= 1)
605 error (_("Invalid MI command"));
607 print_thread_info (current_uiout
, argv
[0], -1);
610 struct collect_cores_data
618 collect_cores (struct thread_info
*ti
, void *xdata
)
620 struct collect_cores_data
*data
= (struct collect_cores_data
*) xdata
;
622 if (ptid_get_pid (ti
->ptid
) == data
->pid
)
624 int core
= target_core_of_thread (ti
->ptid
);
627 VEC_safe_push (int, data
->cores
, core
);
634 unique (int *b
, int *e
)
644 struct print_one_inferior_data
647 VEC (int) *inferiors
;
651 print_one_inferior (struct inferior
*inferior
, void *xdata
)
653 struct print_one_inferior_data
*top_data
654 = (struct print_one_inferior_data
*) xdata
;
655 struct ui_out
*uiout
= current_uiout
;
657 if (VEC_empty (int, top_data
->inferiors
)
658 || bsearch (&(inferior
->pid
), VEC_address (int, top_data
->inferiors
),
659 VEC_length (int, top_data
->inferiors
), sizeof (int),
660 compare_positive_ints
))
662 struct collect_cores_data data
;
663 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
665 uiout
->field_fmt ("id", "i%d", inferior
->num
);
666 uiout
->field_string ("type", "process");
667 if (inferior
->has_exit_code
)
668 uiout
->field_string ("exit-code",
669 int_string (inferior
->exit_code
, 8, 0, 0, 1));
670 if (inferior
->pid
!= 0)
671 uiout
->field_int ("pid", inferior
->pid
);
673 if (inferior
->pspace
->pspace_exec_filename
!= NULL
)
675 uiout
->field_string ("executable",
676 inferior
->pspace
->pspace_exec_filename
);
680 if (inferior
->pid
!= 0)
682 data
.pid
= inferior
->pid
;
683 iterate_over_threads (collect_cores
, &data
);
686 if (!VEC_empty (int, data
.cores
))
689 ui_out_emit_list
list_emitter (uiout
, "cores");
691 qsort (VEC_address (int, data
.cores
),
692 VEC_length (int, data
.cores
), sizeof (int),
693 compare_positive_ints
);
695 b
= VEC_address (int, data
.cores
);
696 e
= b
+ VEC_length (int, data
.cores
);
700 uiout
->field_int (NULL
, *b
);
703 if (top_data
->recurse
)
704 print_thread_info (uiout
, NULL
, inferior
->pid
);
710 /* Output a field named 'cores' with a list as the value. The
711 elements of the list are obtained by splitting 'cores' on
715 output_cores (struct ui_out
*uiout
, const char *field_name
, const char *xcores
)
717 ui_out_emit_list
list_emitter (uiout
, field_name
);
718 gdb::unique_xmalloc_ptr
<char> cores (xstrdup (xcores
));
719 char *p
= cores
.get ();
721 for (p
= strtok (p
, ","); p
; p
= strtok (NULL
, ","))
722 uiout
->field_string (NULL
, p
);
726 free_vector_of_ints (void *xvector
)
728 VEC (int) **vector
= (VEC (int) **) xvector
;
730 VEC_free (int, *vector
);
734 do_nothing (splay_tree_key k
)
739 free_vector_of_osdata_items (splay_tree_value xvalue
)
741 VEC (osdata_item_s
) *value
= (VEC (osdata_item_s
) *) xvalue
;
743 /* We don't free the items itself, it will be done separately. */
744 VEC_free (osdata_item_s
, value
);
748 splay_tree_int_comparator (splay_tree_key xa
, splay_tree_key xb
)
757 free_splay_tree (void *xt
)
759 splay_tree t
= (splay_tree
) xt
;
760 splay_tree_delete (t
);
764 list_available_thread_groups (VEC (int) *ids
, int recurse
)
767 struct osdata_item
*item
;
769 struct ui_out
*uiout
= current_uiout
;
770 struct cleanup
*cleanup
;
772 /* This keeps a map from integer (pid) to VEC (struct osdata_item *)*
773 The vector contains information about all threads for the given pid.
774 This is assigned an initial value to avoid "may be used uninitialized"
776 splay_tree tree
= NULL
;
778 /* get_osdata will throw if it cannot return data. */
779 data
= get_osdata ("processes");
780 cleanup
= make_cleanup_osdata_free (data
);
784 struct osdata
*threads
= get_osdata ("threads");
786 make_cleanup_osdata_free (threads
);
787 tree
= splay_tree_new (splay_tree_int_comparator
,
789 free_vector_of_osdata_items
);
790 make_cleanup (free_splay_tree
, tree
);
793 VEC_iterate (osdata_item_s
, threads
->items
,
797 const char *pid
= get_osdata_column (item
, "pid");
798 int pid_i
= strtoul (pid
, NULL
, 0);
799 VEC (osdata_item_s
) *vec
= 0;
801 splay_tree_node n
= splay_tree_lookup (tree
, pid_i
);
804 VEC_safe_push (osdata_item_s
, vec
, item
);
805 splay_tree_insert (tree
, pid_i
, (splay_tree_value
)vec
);
809 vec
= (VEC (osdata_item_s
) *) n
->value
;
810 VEC_safe_push (osdata_item_s
, vec
, item
);
811 n
->value
= (splay_tree_value
) vec
;
816 ui_out_emit_list
list_emitter (uiout
, "groups");
819 VEC_iterate (osdata_item_s
, data
->items
,
823 const char *pid
= get_osdata_column (item
, "pid");
824 const char *cmd
= get_osdata_column (item
, "command");
825 const char *user
= get_osdata_column (item
, "user");
826 const char *cores
= get_osdata_column (item
, "cores");
828 int pid_i
= strtoul (pid
, NULL
, 0);
830 /* At present, the target will return all available processes
831 and if information about specific ones was required, we filter
832 undesired processes here. */
833 if (ids
&& bsearch (&pid_i
, VEC_address (int, ids
),
834 VEC_length (int, ids
),
835 sizeof (int), compare_positive_ints
) == NULL
)
839 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
841 uiout
->field_fmt ("id", "%s", pid
);
842 uiout
->field_string ("type", "process");
844 uiout
->field_string ("description", cmd
);
846 uiout
->field_string ("user", user
);
848 output_cores (uiout
, "cores", cores
);
852 splay_tree_node n
= splay_tree_lookup (tree
, pid_i
);
855 VEC (osdata_item_s
) *children
= (VEC (osdata_item_s
) *) n
->value
;
856 struct osdata_item
*child
;
859 ui_out_emit_list
thread_list_emitter (uiout
, "threads");
862 VEC_iterate (osdata_item_s
, children
, ix_child
, child
);
865 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
866 const char *tid
= get_osdata_column (child
, "tid");
867 const char *tcore
= get_osdata_column (child
, "core");
869 uiout
->field_string ("id", tid
);
871 uiout
->field_string ("core", tcore
);
877 do_cleanups (cleanup
);
881 mi_cmd_list_thread_groups (const char *command
, char **argv
, int argc
)
883 struct ui_out
*uiout
= current_uiout
;
884 struct cleanup
*back_to
;
891 AVAILABLE_OPT
, RECURSE_OPT
893 static const struct mi_opt opts
[] =
895 {"-available", AVAILABLE_OPT
, 0},
896 {"-recurse", RECURSE_OPT
, 1},
905 int opt
= mi_getopt ("-list-thread-groups", argc
, argv
, opts
,
910 switch ((enum opt
) opt
)
916 if (strcmp (oarg
, "0") == 0)
918 else if (strcmp (oarg
, "1") == 0)
921 error (_("only '0' and '1' are valid values "
922 "for the '--recurse' option"));
927 for (; oind
< argc
; ++oind
)
932 if (*(argv
[oind
]) != 'i')
933 error (_("invalid syntax of group id '%s'"), argv
[oind
]);
935 inf
= strtoul (argv
[oind
] + 1, &end
, 0);
938 error (_("invalid syntax of group id '%s'"), argv
[oind
]);
939 VEC_safe_push (int, ids
, inf
);
941 if (VEC_length (int, ids
) > 1)
942 qsort (VEC_address (int, ids
),
943 VEC_length (int, ids
),
944 sizeof (int), compare_positive_ints
);
946 back_to
= make_cleanup (free_vector_of_ints
, &ids
);
950 list_available_thread_groups (ids
, recurse
);
952 else if (VEC_length (int, ids
) == 1)
954 /* Local thread groups, single id. */
955 int id
= *VEC_address (int, ids
);
956 struct inferior
*inf
= find_inferior_id (id
);
959 error (_("Non-existent thread group id '%d'"), id
);
961 print_thread_info (uiout
, NULL
, inf
->pid
);
965 struct print_one_inferior_data data
;
967 data
.recurse
= recurse
;
968 data
.inferiors
= ids
;
970 /* Local thread groups. Either no explicit ids -- and we
971 print everything, or several explicit ids. In both cases,
972 we print more than one group, and have to use 'groups'
973 as the top-level element. */
974 ui_out_emit_list
list_emitter (uiout
, "groups");
975 update_thread_list ();
976 iterate_over_inferiors (print_one_inferior
, &data
);
979 do_cleanups (back_to
);
983 mi_cmd_data_list_register_names (const char *command
, char **argv
, int argc
)
985 struct gdbarch
*gdbarch
;
986 struct ui_out
*uiout
= current_uiout
;
990 /* Note that the test for a valid register must include checking the
991 gdbarch_register_name because gdbarch_num_regs may be allocated
992 for the union of the register sets within a family of related
993 processors. In this case, some entries of gdbarch_register_name
994 will change depending upon the particular processor being
997 gdbarch
= get_current_arch ();
998 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1000 ui_out_emit_list
list_emitter (uiout
, "register-names");
1002 if (argc
== 0) /* No args, just do all the regs. */
1008 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1009 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1010 uiout
->field_string (NULL
, "");
1012 uiout
->field_string (NULL
, gdbarch_register_name (gdbarch
, regnum
));
1016 /* Else, list of register #s, just do listed regs. */
1017 for (i
= 0; i
< argc
; i
++)
1019 regnum
= atoi (argv
[i
]);
1020 if (regnum
< 0 || regnum
>= numregs
)
1021 error (_("bad register number"));
1023 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1024 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1025 uiout
->field_string (NULL
, "");
1027 uiout
->field_string (NULL
, gdbarch_register_name (gdbarch
, regnum
));
1032 mi_cmd_data_list_changed_registers (const char *command
, char **argv
, int argc
)
1034 static std::unique_ptr
<struct regcache
> this_regs
;
1035 struct ui_out
*uiout
= current_uiout
;
1036 std::unique_ptr
<struct regcache
> prev_regs
;
1037 struct gdbarch
*gdbarch
;
1038 int regnum
, numregs
, changed
;
1041 /* The last time we visited this function, the current frame's
1042 register contents were saved in THIS_REGS. Move THIS_REGS over
1043 to PREV_REGS, and refresh THIS_REGS with the now-current register
1046 prev_regs
= std::move (this_regs
);
1047 this_regs
= frame_save_as_regcache (get_selected_frame (NULL
));
1049 /* Note that the test for a valid register must include checking the
1050 gdbarch_register_name because gdbarch_num_regs may be allocated
1051 for the union of the register sets within a family of related
1052 processors. In this case, some entries of gdbarch_register_name
1053 will change depending upon the particular processor being
1056 gdbarch
= get_regcache_arch (this_regs
.get ());
1057 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1059 ui_out_emit_list
list_emitter (uiout
, "changed-registers");
1063 /* No args, just do all the regs. */
1068 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1069 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1071 changed
= register_changed_p (regnum
, prev_regs
.get (),
1074 error (_("-data-list-changed-registers: "
1075 "Unable to read register contents."));
1077 uiout
->field_int (NULL
, regnum
);
1081 /* Else, list of register #s, just do listed regs. */
1082 for (i
= 0; i
< argc
; i
++)
1084 regnum
= atoi (argv
[i
]);
1088 && gdbarch_register_name (gdbarch
, regnum
) != NULL
1089 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
1091 changed
= register_changed_p (regnum
, prev_regs
.get (),
1094 error (_("-data-list-changed-registers: "
1095 "Unable to read register contents."));
1097 uiout
->field_int (NULL
, regnum
);
1100 error (_("bad register number"));
1105 register_changed_p (int regnum
, struct regcache
*prev_regs
,
1106 struct regcache
*this_regs
)
1108 struct gdbarch
*gdbarch
= get_regcache_arch (this_regs
);
1109 struct value
*prev_value
, *this_value
;
1112 /* First time through or after gdbarch change consider all registers
1114 if (!prev_regs
|| get_regcache_arch (prev_regs
) != gdbarch
)
1117 /* Get register contents and compare. */
1118 prev_value
= prev_regs
->cooked_read_value (regnum
);
1119 this_value
= this_regs
->cooked_read_value (regnum
);
1120 gdb_assert (prev_value
!= NULL
);
1121 gdb_assert (this_value
!= NULL
);
1123 ret
= value_contents_eq (prev_value
, 0, this_value
, 0,
1124 register_size (gdbarch
, regnum
)) == 0;
1126 release_value (prev_value
);
1127 release_value (this_value
);
1128 value_free (prev_value
);
1129 value_free (this_value
);
1133 /* Return a list of register number and value pairs. The valid
1134 arguments expected are: a letter indicating the format in which to
1135 display the registers contents. This can be one of: x
1136 (hexadecimal), d (decimal), N (natural), t (binary), o (octal), r
1137 (raw). After the format argument there can be a sequence of
1138 numbers, indicating which registers to fetch the content of. If
1139 the format is the only argument, a list of all the registers with
1140 their values is returned. */
1143 mi_cmd_data_list_register_values (const char *command
, char **argv
, int argc
)
1145 struct ui_out
*uiout
= current_uiout
;
1146 struct frame_info
*frame
;
1147 struct gdbarch
*gdbarch
;
1148 int regnum
, numregs
, format
;
1150 int skip_unavailable
= 0;
1156 static const struct mi_opt opts
[] =
1158 {"-skip-unavailable", SKIP_UNAVAILABLE
, 0},
1162 /* Note that the test for a valid register must include checking the
1163 gdbarch_register_name because gdbarch_num_regs may be allocated
1164 for the union of the register sets within a family of related
1165 processors. In this case, some entries of gdbarch_register_name
1166 will change depending upon the particular processor being
1172 int opt
= mi_getopt ("-data-list-register-values", argc
, argv
,
1173 opts
, &oind
, &oarg
);
1177 switch ((enum opt
) opt
)
1179 case SKIP_UNAVAILABLE
:
1180 skip_unavailable
= 1;
1185 if (argc
- oind
< 1)
1186 error (_("-data-list-register-values: Usage: "
1187 "-data-list-register-values [--skip-unavailable] <format>"
1188 " [<regnum1>...<regnumN>]"));
1190 format
= (int) argv
[oind
][0];
1192 frame
= get_selected_frame (NULL
);
1193 gdbarch
= get_frame_arch (frame
);
1194 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1196 ui_out_emit_list
list_emitter (uiout
, "register-values");
1198 if (argc
- oind
== 1)
1200 /* No args, beside the format: do all the regs. */
1205 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1206 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1209 output_register (frame
, regnum
, format
, skip_unavailable
);
1213 /* Else, list of register #s, just do listed regs. */
1214 for (i
= 1 + oind
; i
< argc
; i
++)
1216 regnum
= atoi (argv
[i
]);
1220 && gdbarch_register_name (gdbarch
, regnum
) != NULL
1221 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
1222 output_register (frame
, regnum
, format
, skip_unavailable
);
1224 error (_("bad register number"));
1228 /* Output one register REGNUM's contents in the desired FORMAT. If
1229 SKIP_UNAVAILABLE is true, skip the register if it is
1233 output_register (struct frame_info
*frame
, int regnum
, int format
,
1234 int skip_unavailable
)
1236 struct ui_out
*uiout
= current_uiout
;
1237 struct value
*val
= value_of_register (regnum
, frame
);
1238 struct value_print_options opts
;
1240 if (skip_unavailable
&& !value_entirely_available (val
))
1243 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1244 uiout
->field_int ("number", regnum
);
1254 get_formatted_print_options (&opts
, format
);
1256 val_print (value_type (val
),
1257 value_embedded_offset (val
), 0,
1258 &stb
, 0, val
, &opts
, current_language
);
1259 uiout
->field_stream ("value", stb
);
1262 /* Write given values into registers. The registers and values are
1263 given as pairs. The corresponding MI command is
1264 -data-write-register-values <format>
1265 [<regnum1> <value1>...<regnumN> <valueN>] */
1267 mi_cmd_data_write_register_values (const char *command
, char **argv
, int argc
)
1269 struct regcache
*regcache
;
1270 struct gdbarch
*gdbarch
;
1273 /* Note that the test for a valid register must include checking the
1274 gdbarch_register_name because gdbarch_num_regs may be allocated
1275 for the union of the register sets within a family of related
1276 processors. In this case, some entries of gdbarch_register_name
1277 will change depending upon the particular processor being
1280 regcache
= get_current_regcache ();
1281 gdbarch
= get_regcache_arch (regcache
);
1282 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1285 error (_("-data-write-register-values: Usage: -data-write-register-"
1286 "values <format> [<regnum1> <value1>...<regnumN> <valueN>]"));
1288 if (!target_has_registers
)
1289 error (_("-data-write-register-values: No registers."));
1292 error (_("-data-write-register-values: No regs and values specified."));
1295 error (_("-data-write-register-values: "
1296 "Regs and vals are not in pairs."));
1298 for (i
= 1; i
< argc
; i
= i
+ 2)
1300 int regnum
= atoi (argv
[i
]);
1302 if (regnum
>= 0 && regnum
< numregs
1303 && gdbarch_register_name (gdbarch
, regnum
)
1304 && *gdbarch_register_name (gdbarch
, regnum
))
1308 /* Get the value as a number. */
1309 value
= parse_and_eval_address (argv
[i
+ 1]);
1311 /* Write it down. */
1312 regcache_cooked_write_signed (regcache
, regnum
, value
);
1315 error (_("bad register number"));
1319 /* Evaluate the value of the argument. The argument is an
1320 expression. If the expression contains spaces it needs to be
1321 included in double quotes. */
1324 mi_cmd_data_evaluate_expression (const char *command
, char **argv
, int argc
)
1327 struct value_print_options opts
;
1328 struct ui_out
*uiout
= current_uiout
;
1331 error (_("-data-evaluate-expression: "
1332 "Usage: -data-evaluate-expression expression"));
1334 expression_up expr
= parse_expression (argv
[0]);
1336 val
= evaluate_expression (expr
.get ());
1340 /* Print the result of the expression evaluation. */
1341 get_user_print_options (&opts
);
1343 common_val_print (val
, &stb
, 0, &opts
, current_language
);
1345 uiout
->field_stream ("value", stb
);
1348 /* This is the -data-read-memory command.
1350 ADDR: start address of data to be dumped.
1351 WORD-FORMAT: a char indicating format for the ``word''. See
1353 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
1354 NR_ROW: Number of rows.
1355 NR_COL: The number of colums (words per row).
1356 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
1357 ASCHAR for unprintable characters.
1359 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
1360 displayes them. Returns:
1362 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
1365 The number of bytes read is SIZE*ROW*COL. */
1368 mi_cmd_data_read_memory (const char *command
, char **argv
, int argc
)
1370 struct gdbarch
*gdbarch
= get_current_arch ();
1371 struct ui_out
*uiout
= current_uiout
;
1373 long total_bytes
, nr_cols
, nr_rows
;
1375 struct type
*word_type
;
1387 static const struct mi_opt opts
[] =
1389 {"o", OFFSET_OPT
, 1},
1395 int opt
= mi_getopt ("-data-read-memory", argc
, argv
, opts
,
1400 switch ((enum opt
) opt
)
1403 offset
= atol (oarg
);
1410 if (argc
< 5 || argc
> 6)
1411 error (_("-data-read-memory: Usage: "
1412 "ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR]."));
1414 /* Extract all the arguments. */
1416 /* Start address of the memory dump. */
1417 addr
= parse_and_eval_address (argv
[0]) + offset
;
1418 /* The format character to use when displaying a memory word. See
1419 the ``x'' command. */
1420 word_format
= argv
[1][0];
1421 /* The size of the memory word. */
1422 word_size
= atol (argv
[2]);
1426 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1430 word_type
= builtin_type (gdbarch
)->builtin_int16
;
1434 word_type
= builtin_type (gdbarch
)->builtin_int32
;
1438 word_type
= builtin_type (gdbarch
)->builtin_int64
;
1442 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1445 /* The number of rows. */
1446 nr_rows
= atol (argv
[3]);
1448 error (_("-data-read-memory: invalid number of rows."));
1450 /* Number of bytes per row. */
1451 nr_cols
= atol (argv
[4]);
1453 error (_("-data-read-memory: invalid number of columns."));
1455 /* The un-printable character when printing ascii. */
1461 /* Create a buffer and read it in. */
1462 total_bytes
= word_size
* nr_rows
* nr_cols
;
1464 gdb::byte_vector
mbuf (total_bytes
);
1466 /* Dispatch memory reads to the topmost target, not the flattened
1468 nr_bytes
= target_read (current_target
.beneath
,
1469 TARGET_OBJECT_MEMORY
, NULL
, mbuf
.data (),
1472 error (_("Unable to read memory."));
1474 /* Output the header information. */
1475 uiout
->field_core_addr ("addr", gdbarch
, addr
);
1476 uiout
->field_int ("nr-bytes", nr_bytes
);
1477 uiout
->field_int ("total-bytes", total_bytes
);
1478 uiout
->field_core_addr ("next-row", gdbarch
, addr
+ word_size
* nr_cols
);
1479 uiout
->field_core_addr ("prev-row", gdbarch
, addr
- word_size
* nr_cols
);
1480 uiout
->field_core_addr ("next-page", gdbarch
, addr
+ total_bytes
);
1481 uiout
->field_core_addr ("prev-page", gdbarch
, addr
- total_bytes
);
1483 /* Build the result as a two dimentional table. */
1490 ui_out_emit_list
list_emitter (uiout
, "memory");
1491 for (row
= 0, row_byte
= 0;
1493 row
++, row_byte
+= nr_cols
* word_size
)
1497 struct value_print_options opts
;
1499 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1500 uiout
->field_core_addr ("addr", gdbarch
, addr
+ row_byte
);
1501 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr +
1504 ui_out_emit_list
list_data_emitter (uiout
, "data");
1505 get_formatted_print_options (&opts
, word_format
);
1506 for (col
= 0, col_byte
= row_byte
;
1508 col
++, col_byte
+= word_size
)
1510 if (col_byte
+ word_size
> nr_bytes
)
1512 uiout
->field_string (NULL
, "N/A");
1517 print_scalar_formatted (&mbuf
[col_byte
], word_type
, &opts
,
1518 word_asize
, &stream
);
1519 uiout
->field_stream (NULL
, stream
);
1529 for (byte
= row_byte
;
1530 byte
< row_byte
+ word_size
* nr_cols
; byte
++)
1532 if (byte
>= nr_bytes
)
1534 else if (mbuf
[byte
] < 32 || mbuf
[byte
] > 126)
1535 stream
.putc (aschar
);
1537 stream
.putc (mbuf
[byte
]);
1539 uiout
->field_stream ("ascii", stream
);
1546 mi_cmd_data_read_memory_bytes (const char *command
, char **argv
, int argc
)
1548 struct gdbarch
*gdbarch
= get_current_arch ();
1549 struct ui_out
*uiout
= current_uiout
;
1550 struct cleanup
*cleanups
;
1553 memory_read_result_s
*read_result
;
1555 VEC(memory_read_result_s
) *result
;
1557 int unit_size
= gdbarch_addressable_memory_unit_size (gdbarch
);
1564 static const struct mi_opt opts
[] =
1566 {"o", OFFSET_OPT
, 1},
1572 int opt
= mi_getopt ("-data-read-memory-bytes", argc
, argv
, opts
,
1576 switch ((enum opt
) opt
)
1579 offset
= atol (oarg
);
1587 error (_("Usage: [ -o OFFSET ] ADDR LENGTH."));
1589 addr
= parse_and_eval_address (argv
[0]) + offset
;
1590 length
= atol (argv
[1]);
1592 result
= read_memory_robust (current_target
.beneath
, addr
, length
);
1594 cleanups
= make_cleanup (free_memory_read_result_vector
, &result
);
1596 if (VEC_length (memory_read_result_s
, result
) == 0)
1597 error (_("Unable to read memory."));
1599 ui_out_emit_list
list_emitter (uiout
, "memory");
1601 VEC_iterate (memory_read_result_s
, result
, ix
, read_result
);
1604 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1609 uiout
->field_core_addr ("begin", gdbarch
, read_result
->begin
);
1610 uiout
->field_core_addr ("offset", gdbarch
, read_result
->begin
- addr
);
1611 uiout
->field_core_addr ("end", gdbarch
, read_result
->end
);
1613 alloc_len
= (read_result
->end
- read_result
->begin
) * 2 * unit_size
+ 1;
1614 data
= (char *) xmalloc (alloc_len
);
1616 for (i
= 0, p
= data
;
1617 i
< ((read_result
->end
- read_result
->begin
) * unit_size
);
1620 sprintf (p
, "%02x", read_result
->data
[i
]);
1622 uiout
->field_string ("contents", data
);
1625 do_cleanups (cleanups
);
1628 /* Implementation of the -data-write_memory command.
1630 COLUMN_OFFSET: optional argument. Must be preceded by '-o'. The
1631 offset from the beginning of the memory grid row where the cell to
1633 ADDR: start address of the row in the memory grid where the memory
1634 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
1635 the location to write to.
1636 FORMAT: a char indicating format for the ``word''. See
1638 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
1639 VALUE: value to be written into the memory address.
1641 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1646 mi_cmd_data_write_memory (const char *command
, char **argv
, int argc
)
1648 struct gdbarch
*gdbarch
= get_current_arch ();
1649 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1652 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1653 enough when using a compiler other than GCC. */
1662 static const struct mi_opt opts
[] =
1664 {"o", OFFSET_OPT
, 1},
1670 int opt
= mi_getopt ("-data-write-memory", argc
, argv
, opts
,
1675 switch ((enum opt
) opt
)
1678 offset
= atol (oarg
);
1686 error (_("-data-write-memory: Usage: "
1687 "[-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE."));
1689 /* Extract all the arguments. */
1690 /* Start address of the memory dump. */
1691 addr
= parse_and_eval_address (argv
[0]);
1692 /* The size of the memory word. */
1693 word_size
= atol (argv
[2]);
1695 /* Calculate the real address of the write destination. */
1696 addr
+= (offset
* word_size
);
1698 /* Get the value as a number. */
1699 value
= parse_and_eval_address (argv
[3]);
1700 /* Get the value into an array. */
1701 gdb::byte_vector
buffer (word_size
);
1702 store_signed_integer (buffer
.data (), word_size
, byte_order
, value
);
1703 /* Write it down to memory. */
1704 write_memory_with_notification (addr
, buffer
.data (), word_size
);
1707 /* Implementation of the -data-write-memory-bytes command.
1710 DATA: string of bytes to write at that address
1711 COUNT: number of bytes to be filled (decimal integer). */
1714 mi_cmd_data_write_memory_bytes (const char *command
, char **argv
, int argc
)
1720 size_t len_hex
, len_bytes
, len_units
, i
, steps
, remaining_units
;
1721 long int count_units
;
1722 struct cleanup
*back_to
;
1725 if (argc
!= 2 && argc
!= 3)
1726 error (_("Usage: ADDR DATA [COUNT]."));
1728 addr
= parse_and_eval_address (argv
[0]);
1730 len_hex
= strlen (cdata
);
1731 unit_size
= gdbarch_addressable_memory_unit_size (get_current_arch ());
1733 if (len_hex
% (unit_size
* 2) != 0)
1734 error (_("Hex-encoded '%s' must represent an integral number of "
1735 "addressable memory units."),
1738 len_bytes
= len_hex
/ 2;
1739 len_units
= len_bytes
/ unit_size
;
1742 count_units
= strtoul (argv
[2], NULL
, 10);
1744 count_units
= len_units
;
1746 databuf
= XNEWVEC (gdb_byte
, len_bytes
);
1747 back_to
= make_cleanup (xfree
, databuf
);
1749 for (i
= 0; i
< len_bytes
; ++i
)
1752 if (sscanf (cdata
+ i
* 2, "%02x", &x
) != 1)
1753 error (_("Invalid argument"));
1754 databuf
[i
] = (gdb_byte
) x
;
1757 if (len_units
< count_units
)
1759 /* Pattern is made of less units than count:
1760 repeat pattern to fill memory. */
1761 data
= (gdb_byte
*) xmalloc (count_units
* unit_size
);
1762 make_cleanup (xfree
, data
);
1764 /* Number of times the pattern is entirely repeated. */
1765 steps
= count_units
/ len_units
;
1766 /* Number of remaining addressable memory units. */
1767 remaining_units
= count_units
% len_units
;
1768 for (i
= 0; i
< steps
; i
++)
1769 memcpy (data
+ i
* len_bytes
, databuf
, len_bytes
);
1771 if (remaining_units
> 0)
1772 memcpy (data
+ steps
* len_bytes
, databuf
,
1773 remaining_units
* unit_size
);
1777 /* Pattern is longer than or equal to count:
1778 just copy count addressable memory units. */
1782 write_memory_with_notification (addr
, data
, count_units
);
1784 do_cleanups (back_to
);
1788 mi_cmd_enable_timings (const char *command
, char **argv
, int argc
)
1794 if (strcmp (argv
[0], "yes") == 0)
1796 else if (strcmp (argv
[0], "no") == 0)
1807 error (_("-enable-timings: Usage: %s {yes|no}"), command
);
1811 mi_cmd_list_features (const char *command
, char **argv
, int argc
)
1815 struct ui_out
*uiout
= current_uiout
;
1817 ui_out_emit_list
list_emitter (uiout
, "features");
1818 uiout
->field_string (NULL
, "frozen-varobjs");
1819 uiout
->field_string (NULL
, "pending-breakpoints");
1820 uiout
->field_string (NULL
, "thread-info");
1821 uiout
->field_string (NULL
, "data-read-memory-bytes");
1822 uiout
->field_string (NULL
, "breakpoint-notifications");
1823 uiout
->field_string (NULL
, "ada-task-info");
1824 uiout
->field_string (NULL
, "language-option");
1825 uiout
->field_string (NULL
, "info-gdb-mi-command");
1826 uiout
->field_string (NULL
, "undefined-command-error-code");
1827 uiout
->field_string (NULL
, "exec-run-start-option");
1829 if (ext_lang_initialized_p (get_ext_lang_defn (EXT_LANG_PYTHON
)))
1830 uiout
->field_string (NULL
, "python");
1835 error (_("-list-features should be passed no arguments"));
1839 mi_cmd_list_target_features (const char *command
, char **argv
, int argc
)
1843 struct ui_out
*uiout
= current_uiout
;
1845 ui_out_emit_list
list_emitter (uiout
, "features");
1847 uiout
->field_string (NULL
, "async");
1848 if (target_can_execute_reverse
)
1849 uiout
->field_string (NULL
, "reverse");
1853 error (_("-list-target-features should be passed no arguments"));
1857 mi_cmd_add_inferior (const char *command
, char **argv
, int argc
)
1859 struct inferior
*inf
;
1862 error (_("-add-inferior should be passed no arguments"));
1864 inf
= add_inferior_with_spaces ();
1866 current_uiout
->field_fmt ("inferior", "i%d", inf
->num
);
1869 /* Callback used to find the first inferior other than the current
1873 get_other_inferior (struct inferior
*inf
, void *arg
)
1875 if (inf
== current_inferior ())
1882 mi_cmd_remove_inferior (const char *command
, char **argv
, int argc
)
1885 struct inferior
*inf
;
1888 error (_("-remove-inferior should be passed a single argument"));
1890 if (sscanf (argv
[0], "i%d", &id
) != 1)
1891 error (_("the thread group id is syntactically invalid"));
1893 inf
= find_inferior_id (id
);
1895 error (_("the specified thread group does not exist"));
1898 error (_("cannot remove an active inferior"));
1900 if (inf
== current_inferior ())
1902 struct thread_info
*tp
= 0;
1903 struct inferior
*new_inferior
1904 = iterate_over_inferiors (get_other_inferior
, NULL
);
1906 if (new_inferior
== NULL
)
1907 error (_("Cannot remove last inferior"));
1909 set_current_inferior (new_inferior
);
1910 if (new_inferior
->pid
!= 0)
1911 tp
= any_thread_of_process (new_inferior
->pid
);
1912 switch_to_thread (tp
? tp
->ptid
: null_ptid
);
1913 set_current_program_space (new_inferior
->pspace
);
1916 delete_inferior (inf
);
1921 /* Execute a command within a safe environment.
1922 Return <0 for error; >=0 for ok.
1924 args->action will tell mi_execute_command what action
1925 to perfrom after the given command has executed (display/suppress
1926 prompt, display error). */
1929 captured_mi_execute_command (struct ui_out
*uiout
, struct mi_parse
*context
)
1931 struct mi_interp
*mi
= (struct mi_interp
*) command_interp ();
1932 struct cleanup
*cleanup
;
1935 current_command_ts
= context
->cmd_start
;
1937 current_token
= xstrdup (context
->token
);
1938 cleanup
= make_cleanup (free_current_contents
, ¤t_token
);
1940 running_result_record_printed
= 0;
1942 switch (context
->op
)
1945 /* A MI command was read from the input stream. */
1947 /* FIXME: gdb_???? */
1948 fprintf_unfiltered (mi
->raw_stdout
,
1949 " token=`%s' command=`%s' args=`%s'\n",
1950 context
->token
, context
->command
, context
->args
);
1952 mi_cmd_execute (context
);
1954 /* Print the result if there were no errors.
1956 Remember that on the way out of executing a command, you have
1957 to directly use the mi_interp's uiout, since the command
1958 could have reset the interpreter, in which case the current
1959 uiout will most likely crash in the mi_out_* routines. */
1960 if (!running_result_record_printed
)
1962 fputs_unfiltered (context
->token
, mi
->raw_stdout
);
1963 /* There's no particularly good reason why target-connect results
1964 in not ^done. Should kill ^connected for MI3. */
1965 fputs_unfiltered (strcmp (context
->command
, "target-select") == 0
1966 ? "^connected" : "^done", mi
->raw_stdout
);
1967 mi_out_put (uiout
, mi
->raw_stdout
);
1968 mi_out_rewind (uiout
);
1969 mi_print_timing_maybe (mi
->raw_stdout
);
1970 fputs_unfiltered ("\n", mi
->raw_stdout
);
1973 /* The command does not want anything to be printed. In that
1974 case, the command probably should not have written anything
1975 to uiout, but in case it has written something, discard it. */
1976 mi_out_rewind (uiout
);
1983 /* A CLI command was read from the input stream. */
1984 /* This "feature" will be removed as soon as we have a
1985 complete set of mi commands. */
1986 /* Echo the command on the console. */
1987 fprintf_unfiltered (gdb_stdlog
, "%s\n", context
->command
);
1988 /* Call the "console" interpreter. */
1989 argv
[0] = (char *) INTERP_CONSOLE
;
1990 argv
[1] = context
->command
;
1991 mi_cmd_interpreter_exec ("-interpreter-exec", argv
, 2);
1993 /* If we changed interpreters, DON'T print out anything. */
1994 if (current_interp_named_p (INTERP_MI
)
1995 || current_interp_named_p (INTERP_MI1
)
1996 || current_interp_named_p (INTERP_MI2
)
1997 || current_interp_named_p (INTERP_MI3
))
1999 if (!running_result_record_printed
)
2001 fputs_unfiltered (context
->token
, mi
->raw_stdout
);
2002 fputs_unfiltered ("^done", mi
->raw_stdout
);
2003 mi_out_put (uiout
, mi
->raw_stdout
);
2004 mi_out_rewind (uiout
);
2005 mi_print_timing_maybe (mi
->raw_stdout
);
2006 fputs_unfiltered ("\n", mi
->raw_stdout
);
2009 mi_out_rewind (uiout
);
2015 do_cleanups (cleanup
);
2018 /* Print a gdb exception to the MI output stream. */
2021 mi_print_exception (const char *token
, struct gdb_exception exception
)
2023 struct mi_interp
*mi
= (struct mi_interp
*) current_interpreter ();
2025 fputs_unfiltered (token
, mi
->raw_stdout
);
2026 fputs_unfiltered ("^error,msg=\"", mi
->raw_stdout
);
2027 if (exception
.message
== NULL
)
2028 fputs_unfiltered ("unknown error", mi
->raw_stdout
);
2030 fputstr_unfiltered (exception
.message
, '"', mi
->raw_stdout
);
2031 fputs_unfiltered ("\"", mi
->raw_stdout
);
2033 switch (exception
.error
)
2035 case UNDEFINED_COMMAND_ERROR
:
2036 fputs_unfiltered (",code=\"undefined-command\"", mi
->raw_stdout
);
2040 fputs_unfiltered ("\n", mi
->raw_stdout
);
2043 /* Determine whether the parsed command already notifies the
2044 user_selected_context_changed observer. */
2047 command_notifies_uscc_observer (struct mi_parse
*command
)
2049 if (command
->op
== CLI_COMMAND
)
2051 /* CLI commands "thread" and "inferior" already send it. */
2052 return (strncmp (command
->command
, "thread ", 7) == 0
2053 || strncmp (command
->command
, "inferior ", 9) == 0);
2055 else /* MI_COMMAND */
2057 if (strcmp (command
->command
, "interpreter-exec") == 0
2058 && command
->argc
> 1)
2060 /* "thread" and "inferior" again, but through -interpreter-exec. */
2061 return (strncmp (command
->argv
[1], "thread ", 7) == 0
2062 || strncmp (command
->argv
[1], "inferior ", 9) == 0);
2066 /* -thread-select already sends it. */
2067 return strcmp (command
->command
, "thread-select") == 0;
2072 mi_execute_command (const char *cmd
, int from_tty
)
2075 std::unique_ptr
<struct mi_parse
> command
;
2077 /* This is to handle EOF (^D). We just quit gdb. */
2078 /* FIXME: we should call some API function here. */
2080 quit_force (NULL
, from_tty
);
2082 target_log_command (cmd
);
2086 command
= mi_parse (cmd
, &token
);
2088 CATCH (exception
, RETURN_MASK_ALL
)
2090 mi_print_exception (token
, exception
);
2095 if (command
!= NULL
)
2097 ptid_t previous_ptid
= inferior_ptid
;
2099 gdb::optional
<scoped_restore_tmpl
<int>> restore_suppress
;
2101 if (command
->cmd
!= NULL
&& command
->cmd
->suppress_notification
!= NULL
)
2102 restore_suppress
.emplace (command
->cmd
->suppress_notification
, 1);
2104 command
->token
= token
;
2108 command
->cmd_start
= new mi_timestamp ();
2109 timestamp (command
->cmd_start
);
2114 captured_mi_execute_command (current_uiout
, command
.get ());
2116 CATCH (result
, RETURN_MASK_ALL
)
2118 /* Like in start_event_loop, enable input and force display
2119 of the prompt. Otherwise, any command that calls
2120 async_disable_stdin, and then throws, will leave input
2122 async_enable_stdin ();
2123 current_ui
->prompt_state
= PROMPT_NEEDED
;
2125 /* The command execution failed and error() was called
2127 mi_print_exception (command
->token
, result
);
2128 mi_out_rewind (current_uiout
);
2132 bpstat_do_actions ();
2134 if (/* The notifications are only output when the top-level
2135 interpreter (specified on the command line) is MI. */
2136 interp_ui_out (top_level_interpreter ())->is_mi_like_p ()
2137 /* Don't try report anything if there are no threads --
2138 the program is dead. */
2139 && thread_count () != 0
2140 /* If the command already reports the thread change, no need to do it
2142 && !command_notifies_uscc_observer (command
.get ()))
2144 struct mi_interp
*mi
= (struct mi_interp
*) top_level_interpreter ();
2145 int report_change
= 0;
2147 if (command
->thread
== -1)
2149 report_change
= (!ptid_equal (previous_ptid
, null_ptid
)
2150 && !ptid_equal (inferior_ptid
, previous_ptid
)
2151 && !ptid_equal (inferior_ptid
, null_ptid
));
2153 else if (!ptid_equal (inferior_ptid
, null_ptid
))
2155 struct thread_info
*ti
= inferior_thread ();
2157 report_change
= (ti
->global_num
!= command
->thread
);
2162 observer_notify_user_selected_context_changed
2163 (USER_SELECTED_THREAD
| USER_SELECTED_FRAME
);
2170 mi_cmd_execute (struct mi_parse
*parse
)
2172 struct cleanup
*cleanup
;
2174 cleanup
= prepare_execute_command ();
2176 if (parse
->all
&& parse
->thread_group
!= -1)
2177 error (_("Cannot specify --thread-group together with --all"));
2179 if (parse
->all
&& parse
->thread
!= -1)
2180 error (_("Cannot specify --thread together with --all"));
2182 if (parse
->thread_group
!= -1 && parse
->thread
!= -1)
2183 error (_("Cannot specify --thread together with --thread-group"));
2185 if (parse
->frame
!= -1 && parse
->thread
== -1)
2186 error (_("Cannot specify --frame without --thread"));
2188 if (parse
->thread_group
!= -1)
2190 struct inferior
*inf
= find_inferior_id (parse
->thread_group
);
2191 struct thread_info
*tp
= 0;
2194 error (_("Invalid thread group for the --thread-group option"));
2196 set_current_inferior (inf
);
2197 /* This behaviour means that if --thread-group option identifies
2198 an inferior with multiple threads, then a random one will be
2199 picked. This is not a problem -- frontend should always
2200 provide --thread if it wishes to operate on a specific
2203 tp
= any_live_thread_of_process (inf
->pid
);
2204 switch_to_thread (tp
? tp
->ptid
: null_ptid
);
2205 set_current_program_space (inf
->pspace
);
2208 if (parse
->thread
!= -1)
2210 struct thread_info
*tp
= find_thread_global_id (parse
->thread
);
2213 error (_("Invalid thread id: %d"), parse
->thread
);
2215 if (is_exited (tp
->ptid
))
2216 error (_("Thread id: %d has terminated"), parse
->thread
);
2218 switch_to_thread (tp
->ptid
);
2221 if (parse
->frame
!= -1)
2223 struct frame_info
*fid
;
2224 int frame
= parse
->frame
;
2226 fid
= find_relative_frame (get_current_frame (), &frame
);
2228 /* find_relative_frame was successful */
2231 error (_("Invalid frame id: %d"), frame
);
2234 gdb::optional
<scoped_restore_current_language
> lang_saver
;
2235 if (parse
->language
!= language_unknown
)
2237 lang_saver
.emplace ();
2238 set_language (parse
->language
);
2241 current_context
= parse
;
2243 if (parse
->cmd
->argv_func
!= NULL
)
2245 parse
->cmd
->argv_func (parse
->command
, parse
->argv
, parse
->argc
);
2247 else if (parse
->cmd
->cli
.cmd
!= 0)
2249 /* FIXME: DELETE THIS. */
2250 /* The operation is still implemented by a cli command. */
2251 /* Must be a synchronous one. */
2252 mi_execute_cli_command (parse
->cmd
->cli
.cmd
, parse
->cmd
->cli
.args_p
,
2257 /* FIXME: DELETE THIS. */
2260 stb
.puts ("Undefined mi command: ");
2261 stb
.putstr (parse
->command
, '"');
2262 stb
.puts (" (missing implementation)");
2266 do_cleanups (cleanup
);
2269 /* FIXME: This is just a hack so we can get some extra commands going.
2270 We don't want to channel things through the CLI, but call libgdb directly.
2271 Use only for synchronous commands. */
2274 mi_execute_cli_command (const char *cmd
, int args_p
, const char *args
)
2278 struct cleanup
*old_cleanups
;
2282 run
= xstrprintf ("%s %s", cmd
, args
);
2284 run
= xstrdup (cmd
);
2286 /* FIXME: gdb_???? */
2287 fprintf_unfiltered (gdb_stdout
, "cli=%s run=%s\n",
2289 old_cleanups
= make_cleanup (xfree
, run
);
2290 execute_command (run
, 0 /* from_tty */ );
2291 do_cleanups (old_cleanups
);
2297 mi_execute_async_cli_command (const char *cli_command
, char **argv
, int argc
)
2299 struct cleanup
*old_cleanups
;
2303 run
= xstrprintf ("%s %s&", cli_command
, argc
? *argv
: "");
2305 run
= xstrprintf ("%s %s", cli_command
, argc
? *argv
: "");
2306 old_cleanups
= make_cleanup (xfree
, run
);
2308 execute_command (run
, 0 /* from_tty */ );
2310 /* Do this before doing any printing. It would appear that some
2311 print code leaves garbage around in the buffer. */
2312 do_cleanups (old_cleanups
);
2316 mi_load_progress (const char *section_name
,
2317 unsigned long sent_so_far
,
2318 unsigned long total_section
,
2319 unsigned long total_sent
,
2320 unsigned long grand_total
)
2322 using namespace std::chrono
;
2323 static steady_clock::time_point last_update
;
2324 static char *previous_sect_name
= NULL
;
2326 struct mi_interp
*mi
= (struct mi_interp
*) current_interpreter ();
2328 /* This function is called through deprecated_show_load_progress
2329 which means uiout may not be correct. Fix it for the duration
2330 of this function. */
2332 std::unique_ptr
<ui_out
> uiout
;
2334 if (current_interp_named_p (INTERP_MI
)
2335 || current_interp_named_p (INTERP_MI2
))
2336 uiout
.reset (mi_out_new (2));
2337 else if (current_interp_named_p (INTERP_MI1
))
2338 uiout
.reset (mi_out_new (1));
2339 else if (current_interp_named_p (INTERP_MI3
))
2340 uiout
.reset (mi_out_new (3));
2344 scoped_restore save_uiout
2345 = make_scoped_restore (¤t_uiout
, uiout
.get ());
2347 new_section
= (previous_sect_name
?
2348 strcmp (previous_sect_name
, section_name
) : 1);
2351 xfree (previous_sect_name
);
2352 previous_sect_name
= xstrdup (section_name
);
2355 fputs_unfiltered (current_token
, mi
->raw_stdout
);
2356 fputs_unfiltered ("+download", mi
->raw_stdout
);
2358 ui_out_emit_tuple
tuple_emitter (uiout
.get (), NULL
);
2359 uiout
->field_string ("section", section_name
);
2360 uiout
->field_int ("section-size", total_section
);
2361 uiout
->field_int ("total-size", grand_total
);
2363 mi_out_put (uiout
.get (), mi
->raw_stdout
);
2364 fputs_unfiltered ("\n", mi
->raw_stdout
);
2365 gdb_flush (mi
->raw_stdout
);
2368 steady_clock::time_point time_now
= steady_clock::now ();
2369 if (time_now
- last_update
> milliseconds (500))
2371 last_update
= time_now
;
2373 fputs_unfiltered (current_token
, mi
->raw_stdout
);
2374 fputs_unfiltered ("+download", mi
->raw_stdout
);
2376 ui_out_emit_tuple
tuple_emitter (uiout
.get (), NULL
);
2377 uiout
->field_string ("section", section_name
);
2378 uiout
->field_int ("section-sent", sent_so_far
);
2379 uiout
->field_int ("section-size", total_section
);
2380 uiout
->field_int ("total-sent", total_sent
);
2381 uiout
->field_int ("total-size", grand_total
);
2383 mi_out_put (uiout
.get (), mi
->raw_stdout
);
2384 fputs_unfiltered ("\n", mi
->raw_stdout
);
2385 gdb_flush (mi
->raw_stdout
);
2390 timestamp (struct mi_timestamp
*tv
)
2392 using namespace std::chrono
;
2394 tv
->wallclock
= steady_clock::now ();
2395 run_time_clock::now (tv
->utime
, tv
->stime
);
2399 print_diff_now (struct ui_file
*file
, struct mi_timestamp
*start
)
2401 struct mi_timestamp now
;
2404 print_diff (file
, start
, &now
);
2408 mi_print_timing_maybe (struct ui_file
*file
)
2410 /* If the command is -enable-timing then do_timings may be true
2411 whilst current_command_ts is not initialized. */
2412 if (do_timings
&& current_command_ts
)
2413 print_diff_now (file
, current_command_ts
);
2417 print_diff (struct ui_file
*file
, struct mi_timestamp
*start
,
2418 struct mi_timestamp
*end
)
2420 using namespace std::chrono
;
2422 duration
<double> wallclock
= end
->wallclock
- start
->wallclock
;
2423 duration
<double> utime
= end
->utime
- start
->utime
;
2424 duration
<double> stime
= end
->stime
- start
->stime
;
2428 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
2429 wallclock
.count (), utime
.count (), stime
.count ());
2433 mi_cmd_trace_define_variable (const char *command
, char **argv
, int argc
)
2435 LONGEST initval
= 0;
2436 struct trace_state_variable
*tsv
;
2439 if (argc
!= 1 && argc
!= 2)
2440 error (_("Usage: -trace-define-variable VARIABLE [VALUE]"));
2444 error (_("Name of trace variable should start with '$'"));
2446 validate_trace_state_variable_name (name
);
2448 tsv
= find_trace_state_variable (name
);
2450 tsv
= create_trace_state_variable (name
);
2453 initval
= value_as_long (parse_and_eval (argv
[1]));
2455 tsv
->initial_value
= initval
;
2459 mi_cmd_trace_list_variables (const char *command
, char **argv
, int argc
)
2462 error (_("-trace-list-variables: no arguments allowed"));
2464 tvariables_info_1 ();
2468 mi_cmd_trace_find (const char *command
, char **argv
, int argc
)
2473 error (_("trace selection mode is required"));
2477 if (strcmp (mode
, "none") == 0)
2479 tfind_1 (tfind_number
, -1, 0, 0, 0);
2483 check_trace_running (current_trace_status ());
2485 if (strcmp (mode
, "frame-number") == 0)
2488 error (_("frame number is required"));
2489 tfind_1 (tfind_number
, atoi (argv
[1]), 0, 0, 0);
2491 else if (strcmp (mode
, "tracepoint-number") == 0)
2494 error (_("tracepoint number is required"));
2495 tfind_1 (tfind_tp
, atoi (argv
[1]), 0, 0, 0);
2497 else if (strcmp (mode
, "pc") == 0)
2500 error (_("PC is required"));
2501 tfind_1 (tfind_pc
, 0, parse_and_eval_address (argv
[1]), 0, 0);
2503 else if (strcmp (mode
, "pc-inside-range") == 0)
2506 error (_("Start and end PC are required"));
2507 tfind_1 (tfind_range
, 0, parse_and_eval_address (argv
[1]),
2508 parse_and_eval_address (argv
[2]), 0);
2510 else if (strcmp (mode
, "pc-outside-range") == 0)
2513 error (_("Start and end PC are required"));
2514 tfind_1 (tfind_outside
, 0, parse_and_eval_address (argv
[1]),
2515 parse_and_eval_address (argv
[2]), 0);
2517 else if (strcmp (mode
, "line") == 0)
2520 error (_("Line is required"));
2522 std::vector
<symtab_and_line
> sals
2523 = decode_line_with_current_source (argv
[1],
2524 DECODE_LINE_FUNFIRSTLINE
);
2525 const symtab_and_line
&sal
= sals
[0];
2527 if (sal
.symtab
== 0)
2528 error (_("Could not find the specified line"));
2530 CORE_ADDR start_pc
, end_pc
;
2531 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2532 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, 0);
2534 error (_("Could not find the specified line"));
2537 error (_("Invalid mode '%s'"), mode
);
2539 if (has_stack_frames () || get_traceframe_number () >= 0)
2540 print_stack_frame (get_selected_frame (NULL
), 1, LOC_AND_ADDRESS
, 1);
2544 mi_cmd_trace_save (const char *command
, char **argv
, int argc
)
2546 int target_saves
= 0;
2547 int generate_ctf
= 0;
2554 TARGET_SAVE_OPT
, CTF_OPT
2556 static const struct mi_opt opts
[] =
2558 {"r", TARGET_SAVE_OPT
, 0},
2559 {"ctf", CTF_OPT
, 0},
2565 int opt
= mi_getopt ("-trace-save", argc
, argv
, opts
,
2570 switch ((enum opt
) opt
)
2572 case TARGET_SAVE_OPT
:
2581 if (argc
- oind
!= 1)
2582 error (_("Exactly one argument required "
2583 "(file in which to save trace data)"));
2585 filename
= argv
[oind
];
2588 trace_save_ctf (filename
, target_saves
);
2590 trace_save_tfile (filename
, target_saves
);
2594 mi_cmd_trace_start (const char *command
, char **argv
, int argc
)
2596 start_tracing (NULL
);
2600 mi_cmd_trace_status (const char *command
, char **argv
, int argc
)
2602 trace_status_mi (0);
2606 mi_cmd_trace_stop (const char *command
, char **argv
, int argc
)
2608 stop_tracing (NULL
);
2609 trace_status_mi (1);
2612 /* Implement the "-ada-task-info" command. */
2615 mi_cmd_ada_task_info (const char *command
, char **argv
, int argc
)
2617 if (argc
!= 0 && argc
!= 1)
2618 error (_("Invalid MI command"));
2620 print_ada_task_info (current_uiout
, argv
[0], current_inferior ());
2623 /* Print EXPRESSION according to VALUES. */
2626 print_variable_or_computed (const char *expression
, enum print_values values
)
2630 struct ui_out
*uiout
= current_uiout
;
2634 expression_up expr
= parse_expression (expression
);
2636 if (values
== PRINT_SIMPLE_VALUES
)
2637 val
= evaluate_type (expr
.get ());
2639 val
= evaluate_expression (expr
.get ());
2641 gdb::optional
<ui_out_emit_tuple
> tuple_emitter
;
2642 if (values
!= PRINT_NO_VALUES
)
2643 tuple_emitter
.emplace (uiout
, nullptr);
2644 uiout
->field_string ("name", expression
);
2648 case PRINT_SIMPLE_VALUES
:
2649 type
= check_typedef (value_type (val
));
2650 type_print (value_type (val
), "", &stb
, -1);
2651 uiout
->field_stream ("type", stb
);
2652 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
2653 && TYPE_CODE (type
) != TYPE_CODE_STRUCT
2654 && TYPE_CODE (type
) != TYPE_CODE_UNION
)
2656 struct value_print_options opts
;
2658 get_no_prettyformat_print_options (&opts
);
2660 common_val_print (val
, &stb
, 0, &opts
, current_language
);
2661 uiout
->field_stream ("value", stb
);
2664 case PRINT_ALL_VALUES
:
2666 struct value_print_options opts
;
2668 get_no_prettyformat_print_options (&opts
);
2670 common_val_print (val
, &stb
, 0, &opts
, current_language
);
2671 uiout
->field_stream ("value", stb
);
2677 /* Implement the "-trace-frame-collected" command. */
2680 mi_cmd_trace_frame_collected (const char *command
, char **argv
, int argc
)
2682 struct bp_location
*tloc
;
2684 struct collection_list
*clist
;
2685 struct collection_list tracepoint_list
, stepping_list
;
2686 struct traceframe_info
*tinfo
;
2688 enum print_values var_print_values
= PRINT_ALL_VALUES
;
2689 enum print_values comp_print_values
= PRINT_ALL_VALUES
;
2690 int registers_format
= 'x';
2691 int memory_contents
= 0;
2692 struct ui_out
*uiout
= current_uiout
;
2700 static const struct mi_opt opts
[] =
2702 {"-var-print-values", VAR_PRINT_VALUES
, 1},
2703 {"-comp-print-values", COMP_PRINT_VALUES
, 1},
2704 {"-registers-format", REGISTERS_FORMAT
, 1},
2705 {"-memory-contents", MEMORY_CONTENTS
, 0},
2712 int opt
= mi_getopt ("-trace-frame-collected", argc
, argv
, opts
,
2716 switch ((enum opt
) opt
)
2718 case VAR_PRINT_VALUES
:
2719 var_print_values
= mi_parse_print_values (oarg
);
2721 case COMP_PRINT_VALUES
:
2722 comp_print_values
= mi_parse_print_values (oarg
);
2724 case REGISTERS_FORMAT
:
2725 registers_format
= oarg
[0];
2726 case MEMORY_CONTENTS
:
2727 memory_contents
= 1;
2733 error (_("Usage: -trace-frame-collected "
2734 "[--var-print-values PRINT_VALUES] "
2735 "[--comp-print-values PRINT_VALUES] "
2736 "[--registers-format FORMAT]"
2737 "[--memory-contents]"));
2739 /* This throws an error is not inspecting a trace frame. */
2740 tloc
= get_traceframe_location (&stepping_frame
);
2742 /* This command only makes sense for the current frame, not the
2744 scoped_restore_current_thread restore_thread
;
2745 select_frame (get_current_frame ());
2747 encode_actions (tloc
, &tracepoint_list
, &stepping_list
);
2750 clist
= &stepping_list
;
2752 clist
= &tracepoint_list
;
2754 tinfo
= get_traceframe_info ();
2756 /* Explicitly wholly collected variables. */
2760 ui_out_emit_list
list_emitter (uiout
, "explicit-variables");
2761 const std::vector
<std::string
> &wholly_collected
2762 = clist
->wholly_collected ();
2763 for (size_t i
= 0; i
< wholly_collected
.size (); i
++)
2765 const std::string
&str
= wholly_collected
[i
];
2766 print_variable_or_computed (str
.c_str (), var_print_values
);
2770 /* Computed expressions. */
2775 ui_out_emit_list
list_emitter (uiout
, "computed-expressions");
2777 const std::vector
<std::string
> &computed
= clist
->computed ();
2778 for (size_t i
= 0; i
< computed
.size (); i
++)
2780 const std::string
&str
= computed
[i
];
2781 print_variable_or_computed (str
.c_str (), comp_print_values
);
2785 /* Registers. Given pseudo-registers, and that some architectures
2786 (like MIPS) actually hide the raw registers, we don't go through
2787 the trace frame info, but instead consult the register cache for
2788 register availability. */
2790 struct frame_info
*frame
;
2791 struct gdbarch
*gdbarch
;
2795 ui_out_emit_list
list_emitter (uiout
, "registers");
2797 frame
= get_selected_frame (NULL
);
2798 gdbarch
= get_frame_arch (frame
);
2799 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
2801 for (regnum
= 0; regnum
< numregs
; regnum
++)
2803 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
2804 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
2807 output_register (frame
, regnum
, registers_format
, 1);
2811 /* Trace state variables. */
2813 struct cleanup
*cleanups
;
2818 ui_out_emit_list
list_emitter (uiout
, "tvars");
2821 cleanups
= make_cleanup (free_current_contents
, &tsvname
);
2823 for (i
= 0; VEC_iterate (int, tinfo
->tvars
, i
, tvar
); i
++)
2825 struct trace_state_variable
*tsv
;
2827 tsv
= find_trace_state_variable_by_number (tvar
);
2829 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
2833 tsvname
= (char *) xrealloc (tsvname
, strlen (tsv
->name
) + 2);
2835 strcpy (tsvname
+ 1, tsv
->name
);
2836 uiout
->field_string ("name", tsvname
);
2838 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
2840 uiout
->field_int ("current", tsv
->value
);
2844 uiout
->field_skip ("name");
2845 uiout
->field_skip ("current");
2849 do_cleanups (cleanups
);
2854 struct cleanup
*cleanups
;
2855 VEC(mem_range_s
) *available_memory
= NULL
;
2856 struct mem_range
*r
;
2859 traceframe_available_memory (&available_memory
, 0, ULONGEST_MAX
);
2860 cleanups
= make_cleanup (VEC_cleanup(mem_range_s
), &available_memory
);
2862 ui_out_emit_list
list_emitter (uiout
, "memory");
2864 for (i
= 0; VEC_iterate (mem_range_s
, available_memory
, i
, r
); i
++)
2866 struct gdbarch
*gdbarch
= target_gdbarch ();
2868 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
2870 uiout
->field_core_addr ("address", gdbarch
, r
->start
);
2871 uiout
->field_int ("length", r
->length
);
2873 gdb::byte_vector
data (r
->length
);
2875 if (memory_contents
)
2877 if (target_read_memory (r
->start
, data
.data (), r
->length
) == 0)
2879 std::string data_str
= bin2hex (data
.data (), r
->length
);
2880 uiout
->field_string ("contents", data_str
.c_str ());
2883 uiout
->field_skip ("contents");
2887 do_cleanups (cleanups
);
2892 _initialize_mi_main (void)
2894 struct cmd_list_element
*c
;
2896 add_setshow_boolean_cmd ("mi-async", class_run
,
2898 Set whether MI asynchronous mode is enabled."), _("\
2899 Show whether MI asynchronous mode is enabled."), _("\
2900 Tells GDB whether MI should be in asynchronous mode."),
2901 set_mi_async_command
,
2902 show_mi_async_command
,
2906 /* Alias old "target-async" to "mi-async". */
2907 c
= add_alias_cmd ("target-async", "mi-async", class_run
, 0, &setlist
);
2908 deprecate_cmd (c
, "set mi-async");
2909 c
= add_alias_cmd ("target-async", "mi-async", class_run
, 0, &showlist
);
2910 deprecate_cmd (c
, "show mi-async");