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"
72 /* This is used to pass the current command timestamp down to
73 continuation routines. */
74 static struct mi_timestamp
*current_command_ts
;
76 static int do_timings
= 0;
79 /* Few commands would like to know if options like --thread-group were
80 explicitly specified. This variable keeps the current parsed
81 command including all option, and make it possible. */
82 static struct mi_parse
*current_context
;
84 int running_result_record_printed
= 1;
86 /* Flag indicating that the target has proceeded since the last
87 command was issued. */
90 static void mi_cmd_execute (struct mi_parse
*parse
);
92 static void mi_execute_cli_command (const char *cmd
, int args_p
,
94 static void mi_execute_async_cli_command (const char *cli_command
,
95 char **argv
, int argc
);
96 static int register_changed_p (int regnum
, struct regcache
*,
98 static void output_register (struct frame_info
*, int regnum
, int format
,
99 int skip_unavailable
);
101 /* Controls whether the frontend wants MI in async mode. */
102 static int mi_async
= 0;
104 /* The set command writes to this variable. If the inferior is
105 executing, mi_async is *not* updated. */
106 static int mi_async_1
= 0;
109 set_mi_async_command (char *args
, int from_tty
,
110 struct cmd_list_element
*c
)
112 if (have_live_inferiors ())
114 mi_async_1
= mi_async
;
115 error (_("Cannot change this setting while the inferior is running."));
118 mi_async
= mi_async_1
;
122 show_mi_async_command (struct ui_file
*file
, int from_tty
,
123 struct cmd_list_element
*c
,
126 fprintf_filtered (file
,
127 _("Whether MI is in asynchronous mode is %s.\n"),
131 /* A wrapper for target_can_async_p that takes the MI setting into
137 return mi_async
&& target_can_async_p ();
140 /* Command implementations. FIXME: Is this libgdb? No. This is the MI
141 layer that calls libgdb. Any operation used in the below should be
144 static void timestamp (struct mi_timestamp
*tv
);
146 static void print_diff (struct ui_file
*file
, struct mi_timestamp
*start
,
147 struct mi_timestamp
*end
);
150 mi_cmd_gdb_exit (const char *command
, char **argv
, int argc
)
152 struct mi_interp
*mi
= (struct mi_interp
*) current_interpreter ();
154 /* We have to print everything right here because we never return. */
156 fputs_unfiltered (current_token
, mi
->raw_stdout
);
157 fputs_unfiltered ("^exit\n", mi
->raw_stdout
);
158 mi_out_put (current_uiout
, mi
->raw_stdout
);
159 gdb_flush (mi
->raw_stdout
);
160 /* FIXME: The function called is not yet a formal libgdb function. */
161 quit_force (NULL
, FROM_TTY
);
165 mi_cmd_exec_next (const char *command
, char **argv
, int argc
)
167 /* FIXME: Should call a libgdb function, not a cli wrapper. */
168 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
169 mi_execute_async_cli_command ("reverse-next", argv
+ 1, argc
- 1);
171 mi_execute_async_cli_command ("next", argv
, argc
);
175 mi_cmd_exec_next_instruction (const char *command
, char **argv
, int argc
)
177 /* FIXME: Should call a libgdb function, not a cli wrapper. */
178 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
179 mi_execute_async_cli_command ("reverse-nexti", argv
+ 1, argc
- 1);
181 mi_execute_async_cli_command ("nexti", argv
, argc
);
185 mi_cmd_exec_step (const char *command
, char **argv
, int argc
)
187 /* FIXME: Should call a libgdb function, not a cli wrapper. */
188 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
189 mi_execute_async_cli_command ("reverse-step", argv
+ 1, argc
- 1);
191 mi_execute_async_cli_command ("step", argv
, argc
);
195 mi_cmd_exec_step_instruction (const char *command
, char **argv
, int argc
)
197 /* FIXME: Should call a libgdb function, not a cli wrapper. */
198 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
199 mi_execute_async_cli_command ("reverse-stepi", argv
+ 1, argc
- 1);
201 mi_execute_async_cli_command ("stepi", argv
, argc
);
205 mi_cmd_exec_finish (const char *command
, char **argv
, int argc
)
207 /* FIXME: Should call a libgdb function, not a cli wrapper. */
208 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
209 mi_execute_async_cli_command ("reverse-finish", argv
+ 1, argc
- 1);
211 mi_execute_async_cli_command ("finish", argv
, argc
);
215 mi_cmd_exec_return (const char *command
, char **argv
, int argc
)
217 /* This command doesn't really execute the target, it just pops the
218 specified number of frames. */
220 /* Call return_command with from_tty argument equal to 0 so as to
221 avoid being queried. */
222 return_command (*argv
, 0);
224 /* Call return_command with from_tty argument equal to 0 so as to
225 avoid being queried. */
226 return_command (NULL
, 0);
228 /* Because we have called return_command with from_tty = 0, we need
229 to print the frame here. */
230 print_stack_frame (get_selected_frame (NULL
), 1, LOC_AND_ADDRESS
, 1);
234 mi_cmd_exec_jump (const char *args
, char **argv
, int argc
)
236 /* FIXME: Should call a libgdb function, not a cli wrapper. */
237 mi_execute_async_cli_command ("jump", argv
, argc
);
241 proceed_thread (struct thread_info
*thread
, int pid
)
243 if (!is_stopped (thread
->ptid
))
246 if (pid
!= 0 && ptid_get_pid (thread
->ptid
) != pid
)
249 switch_to_thread (thread
->ptid
);
250 clear_proceed_status (0);
251 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
);
255 proceed_thread_callback (struct thread_info
*thread
, void *arg
)
257 int pid
= *(int *)arg
;
259 proceed_thread (thread
, pid
);
264 exec_continue (char **argv
, int argc
)
266 prepare_execution_command (¤t_target
, mi_async_p ());
270 /* In non-stop mode, 'resume' always resumes a single thread.
271 Therefore, to resume all threads of the current inferior, or
272 all threads in all inferiors, we need to iterate over
275 See comment on infcmd.c:proceed_thread_callback for rationale. */
276 if (current_context
->all
|| current_context
->thread_group
!= -1)
278 scoped_restore_current_thread restore_thread
;
281 if (!current_context
->all
)
284 = find_inferior_id (current_context
->thread_group
);
288 iterate_over_threads (proceed_thread_callback
, &pid
);
297 scoped_restore save_multi
= make_scoped_restore (&sched_multi
);
299 if (current_context
->all
)
306 /* In all-stop mode, -exec-continue traditionally resumed
307 either all threads, or one thread, depending on the
308 'scheduler-locking' variable. Let's continue to do the
316 exec_reverse_continue (char **argv
, int argc
)
318 enum exec_direction_kind dir
= execution_direction
;
320 if (dir
== EXEC_REVERSE
)
321 error (_("Already in reverse mode."));
323 if (!target_can_execute_reverse
)
324 error (_("Target %s does not support this command."), target_shortname
);
326 scoped_restore save_exec_dir
= make_scoped_restore (&execution_direction
,
328 exec_continue (argv
, argc
);
332 mi_cmd_exec_continue (const char *command
, char **argv
, int argc
)
334 if (argc
> 0 && strcmp (argv
[0], "--reverse") == 0)
335 exec_reverse_continue (argv
+ 1, argc
- 1);
337 exec_continue (argv
, argc
);
341 interrupt_thread_callback (struct thread_info
*thread
, void *arg
)
343 int pid
= *(int *)arg
;
345 if (!is_running (thread
->ptid
))
348 if (ptid_get_pid (thread
->ptid
) != pid
)
351 target_stop (thread
->ptid
);
355 /* Interrupt the execution of the target. Note how we must play
356 around with the token variables, in order to display the current
357 token in the result of the interrupt command, and the previous
358 execution token when the target finally stops. See comments in
362 mi_cmd_exec_interrupt (const char *command
, char **argv
, int argc
)
364 /* In all-stop mode, everything stops, so we don't need to try
365 anything specific. */
368 interrupt_target_1 (0);
372 if (current_context
->all
)
374 /* This will interrupt all threads in all inferiors. */
375 interrupt_target_1 (1);
377 else if (current_context
->thread_group
!= -1)
379 struct inferior
*inf
= find_inferior_id (current_context
->thread_group
);
381 iterate_over_threads (interrupt_thread_callback
, &inf
->pid
);
385 /* Interrupt just the current thread -- either explicitly
386 specified via --thread or whatever was current before
387 MI command was sent. */
388 interrupt_target_1 (0);
392 /* Callback for iterate_over_inferiors which starts the execution
393 of the given inferior.
395 ARG is a pointer to an integer whose value, if non-zero, indicates
396 that the program should be stopped when reaching the main subprogram
397 (similar to what the CLI "start" command does). */
400 run_one_inferior (struct inferior
*inf
, void *arg
)
402 int start_p
= *(int *) arg
;
403 const char *run_cmd
= start_p
? "start" : "run";
404 struct target_ops
*run_target
= find_run_target ();
405 int async_p
= mi_async
&& run_target
->to_can_async_p (run_target
);
409 if (inf
->pid
!= ptid_get_pid (inferior_ptid
))
411 struct thread_info
*tp
;
413 tp
= any_thread_of_process (inf
->pid
);
415 error (_("Inferior has no threads."));
417 switch_to_thread (tp
->ptid
);
422 set_current_inferior (inf
);
423 switch_to_thread (null_ptid
);
424 set_current_program_space (inf
->pspace
);
426 mi_execute_cli_command (run_cmd
, async_p
,
427 async_p
? "&" : NULL
);
432 mi_cmd_exec_run (const char *command
, char **argv
, int argc
)
436 /* Parse the command options. */
441 static const struct mi_opt opts
[] =
443 {"-start", START_OPT
, 0},
452 int opt
= mi_getopt ("-exec-run", argc
, argv
, opts
, &oind
, &oarg
);
456 switch ((enum opt
) opt
)
464 /* This command does not accept any argument. Make sure the user
465 did not provide any. */
467 error (_("Invalid argument: %s"), argv
[oind
]);
469 if (current_context
->all
)
471 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
473 iterate_over_inferiors (run_one_inferior
, &start_p
);
477 const char *run_cmd
= start_p
? "start" : "run";
478 struct target_ops
*run_target
= find_run_target ();
479 int async_p
= mi_async
&& run_target
->to_can_async_p (run_target
);
481 mi_execute_cli_command (run_cmd
, async_p
,
482 async_p
? "&" : NULL
);
488 find_thread_of_process (struct thread_info
*ti
, void *p
)
492 if (ptid_get_pid (ti
->ptid
) == pid
&& !is_exited (ti
->ptid
))
499 mi_cmd_target_detach (const char *command
, char **argv
, int argc
)
501 if (argc
!= 0 && argc
!= 1)
502 error (_("Usage: -target-detach [pid | thread-group]"));
506 struct thread_info
*tp
;
510 /* First see if we are dealing with a thread-group id. */
513 struct inferior
*inf
;
514 int id
= strtoul (argv
[0] + 1, &end
, 0);
517 error (_("Invalid syntax of thread-group id '%s'"), argv
[0]);
519 inf
= find_inferior_id (id
);
521 error (_("Non-existent thread-group id '%d'"), id
);
527 /* We must be dealing with a pid. */
528 pid
= strtol (argv
[0], &end
, 10);
531 error (_("Invalid identifier '%s'"), argv
[0]);
534 /* Pick any thread in the desired process. Current
535 target_detach detaches from the parent of inferior_ptid. */
536 tp
= iterate_over_threads (find_thread_of_process
, &pid
);
538 error (_("Thread group is empty"));
540 switch_to_thread (tp
->ptid
);
543 detach_command (NULL
, 0);
547 mi_cmd_target_flash_erase (const char *command
, char **argv
, int argc
)
549 flash_erase_command (NULL
, 0);
553 mi_cmd_thread_select (const char *command
, char **argv
, int argc
)
556 char *mi_error_message
;
557 ptid_t previous_ptid
= inferior_ptid
;
560 error (_("-thread-select: USAGE: threadnum."));
562 rc
= gdb_thread_select (current_uiout
, argv
[0], &mi_error_message
);
564 /* If thread switch did not succeed don't notify or print. */
565 if (rc
== GDB_RC_FAIL
)
567 make_cleanup (xfree
, mi_error_message
);
568 error ("%s", mi_error_message
);
571 print_selected_thread_frame (current_uiout
,
572 USER_SELECTED_THREAD
| USER_SELECTED_FRAME
);
574 /* Notify if the thread has effectively changed. */
575 if (!ptid_equal (inferior_ptid
, previous_ptid
))
577 observer_notify_user_selected_context_changed (USER_SELECTED_THREAD
578 | USER_SELECTED_FRAME
);
583 mi_cmd_thread_list_ids (const char *command
, char **argv
, int argc
)
586 char *mi_error_message
;
589 error (_("-thread-list-ids: No arguments required."));
591 rc
= gdb_list_thread_ids (current_uiout
, &mi_error_message
);
593 if (rc
== GDB_RC_FAIL
)
595 make_cleanup (xfree
, mi_error_message
);
596 error ("%s", mi_error_message
);
601 mi_cmd_thread_info (const char *command
, char **argv
, int argc
)
603 if (argc
!= 0 && argc
!= 1)
604 error (_("Invalid MI command"));
606 print_thread_info (current_uiout
, argv
[0], -1);
609 struct collect_cores_data
617 collect_cores (struct thread_info
*ti
, void *xdata
)
619 struct collect_cores_data
*data
= (struct collect_cores_data
*) xdata
;
621 if (ptid_get_pid (ti
->ptid
) == data
->pid
)
623 int core
= target_core_of_thread (ti
->ptid
);
626 VEC_safe_push (int, data
->cores
, core
);
633 unique (int *b
, int *e
)
643 struct print_one_inferior_data
646 VEC (int) *inferiors
;
650 print_one_inferior (struct inferior
*inferior
, void *xdata
)
652 struct print_one_inferior_data
*top_data
653 = (struct print_one_inferior_data
*) xdata
;
654 struct ui_out
*uiout
= current_uiout
;
656 if (VEC_empty (int, top_data
->inferiors
)
657 || bsearch (&(inferior
->pid
), VEC_address (int, top_data
->inferiors
),
658 VEC_length (int, top_data
->inferiors
), sizeof (int),
659 compare_positive_ints
))
661 struct collect_cores_data data
;
662 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
664 uiout
->field_fmt ("id", "i%d", inferior
->num
);
665 uiout
->field_string ("type", "process");
666 if (inferior
->has_exit_code
)
667 uiout
->field_string ("exit-code",
668 int_string (inferior
->exit_code
, 8, 0, 0, 1));
669 if (inferior
->pid
!= 0)
670 uiout
->field_int ("pid", inferior
->pid
);
672 if (inferior
->pspace
->pspace_exec_filename
!= NULL
)
674 uiout
->field_string ("executable",
675 inferior
->pspace
->pspace_exec_filename
);
679 if (inferior
->pid
!= 0)
681 data
.pid
= inferior
->pid
;
682 iterate_over_threads (collect_cores
, &data
);
685 if (!VEC_empty (int, data
.cores
))
688 ui_out_emit_list
list_emitter (uiout
, "cores");
690 qsort (VEC_address (int, data
.cores
),
691 VEC_length (int, data
.cores
), sizeof (int),
692 compare_positive_ints
);
694 b
= VEC_address (int, data
.cores
);
695 e
= b
+ VEC_length (int, data
.cores
);
699 uiout
->field_int (NULL
, *b
);
702 if (top_data
->recurse
)
703 print_thread_info (uiout
, NULL
, inferior
->pid
);
709 /* Output a field named 'cores' with a list as the value. The
710 elements of the list are obtained by splitting 'cores' on
714 output_cores (struct ui_out
*uiout
, const char *field_name
, const char *xcores
)
716 struct cleanup
*back_to
= make_cleanup_ui_out_list_begin_end (uiout
,
718 char *cores
= xstrdup (xcores
);
721 make_cleanup (xfree
, cores
);
723 for (p
= strtok (p
, ","); p
; p
= strtok (NULL
, ","))
724 uiout
->field_string (NULL
, p
);
726 do_cleanups (back_to
);
730 free_vector_of_ints (void *xvector
)
732 VEC (int) **vector
= (VEC (int) **) xvector
;
734 VEC_free (int, *vector
);
738 do_nothing (splay_tree_key k
)
743 free_vector_of_osdata_items (splay_tree_value xvalue
)
745 VEC (osdata_item_s
) *value
= (VEC (osdata_item_s
) *) xvalue
;
747 /* We don't free the items itself, it will be done separately. */
748 VEC_free (osdata_item_s
, value
);
752 splay_tree_int_comparator (splay_tree_key xa
, splay_tree_key xb
)
761 free_splay_tree (void *xt
)
763 splay_tree t
= (splay_tree
) xt
;
764 splay_tree_delete (t
);
768 list_available_thread_groups (VEC (int) *ids
, int recurse
)
771 struct osdata_item
*item
;
773 struct ui_out
*uiout
= current_uiout
;
774 struct cleanup
*cleanup
;
776 /* This keeps a map from integer (pid) to VEC (struct osdata_item *)*
777 The vector contains information about all threads for the given pid.
778 This is assigned an initial value to avoid "may be used uninitialized"
780 splay_tree tree
= NULL
;
782 /* get_osdata will throw if it cannot return data. */
783 data
= get_osdata ("processes");
784 cleanup
= make_cleanup_osdata_free (data
);
788 struct osdata
*threads
= get_osdata ("threads");
790 make_cleanup_osdata_free (threads
);
791 tree
= splay_tree_new (splay_tree_int_comparator
,
793 free_vector_of_osdata_items
);
794 make_cleanup (free_splay_tree
, tree
);
797 VEC_iterate (osdata_item_s
, threads
->items
,
801 const char *pid
= get_osdata_column (item
, "pid");
802 int pid_i
= strtoul (pid
, NULL
, 0);
803 VEC (osdata_item_s
) *vec
= 0;
805 splay_tree_node n
= splay_tree_lookup (tree
, pid_i
);
808 VEC_safe_push (osdata_item_s
, vec
, item
);
809 splay_tree_insert (tree
, pid_i
, (splay_tree_value
)vec
);
813 vec
= (VEC (osdata_item_s
) *) n
->value
;
814 VEC_safe_push (osdata_item_s
, vec
, item
);
815 n
->value
= (splay_tree_value
) vec
;
820 make_cleanup_ui_out_list_begin_end (uiout
, "groups");
823 VEC_iterate (osdata_item_s
, data
->items
,
827 const char *pid
= get_osdata_column (item
, "pid");
828 const char *cmd
= get_osdata_column (item
, "command");
829 const char *user
= get_osdata_column (item
, "user");
830 const char *cores
= get_osdata_column (item
, "cores");
832 int pid_i
= strtoul (pid
, NULL
, 0);
834 /* At present, the target will return all available processes
835 and if information about specific ones was required, we filter
836 undesired processes here. */
837 if (ids
&& bsearch (&pid_i
, VEC_address (int, ids
),
838 VEC_length (int, ids
),
839 sizeof (int), compare_positive_ints
) == NULL
)
843 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
845 uiout
->field_fmt ("id", "%s", pid
);
846 uiout
->field_string ("type", "process");
848 uiout
->field_string ("description", cmd
);
850 uiout
->field_string ("user", user
);
852 output_cores (uiout
, "cores", cores
);
856 splay_tree_node n
= splay_tree_lookup (tree
, pid_i
);
859 VEC (osdata_item_s
) *children
= (VEC (osdata_item_s
) *) n
->value
;
860 struct osdata_item
*child
;
863 make_cleanup_ui_out_list_begin_end (uiout
, "threads");
866 VEC_iterate (osdata_item_s
, children
, ix_child
, child
);
869 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
870 const char *tid
= get_osdata_column (child
, "tid");
871 const char *tcore
= get_osdata_column (child
, "core");
873 uiout
->field_string ("id", tid
);
875 uiout
->field_string ("core", tcore
);
881 do_cleanups (cleanup
);
885 mi_cmd_list_thread_groups (const char *command
, char **argv
, int argc
)
887 struct ui_out
*uiout
= current_uiout
;
888 struct cleanup
*back_to
;
895 AVAILABLE_OPT
, RECURSE_OPT
897 static const struct mi_opt opts
[] =
899 {"-available", AVAILABLE_OPT
, 0},
900 {"-recurse", RECURSE_OPT
, 1},
909 int opt
= mi_getopt ("-list-thread-groups", argc
, argv
, opts
,
914 switch ((enum opt
) opt
)
920 if (strcmp (oarg
, "0") == 0)
922 else if (strcmp (oarg
, "1") == 0)
925 error (_("only '0' and '1' are valid values "
926 "for the '--recurse' option"));
931 for (; oind
< argc
; ++oind
)
936 if (*(argv
[oind
]) != 'i')
937 error (_("invalid syntax of group id '%s'"), argv
[oind
]);
939 inf
= strtoul (argv
[oind
] + 1, &end
, 0);
942 error (_("invalid syntax of group id '%s'"), argv
[oind
]);
943 VEC_safe_push (int, ids
, inf
);
945 if (VEC_length (int, ids
) > 1)
946 qsort (VEC_address (int, ids
),
947 VEC_length (int, ids
),
948 sizeof (int), compare_positive_ints
);
950 back_to
= make_cleanup (free_vector_of_ints
, &ids
);
954 list_available_thread_groups (ids
, recurse
);
956 else if (VEC_length (int, ids
) == 1)
958 /* Local thread groups, single id. */
959 int id
= *VEC_address (int, ids
);
960 struct inferior
*inf
= find_inferior_id (id
);
963 error (_("Non-existent thread group id '%d'"), id
);
965 print_thread_info (uiout
, NULL
, inf
->pid
);
969 struct print_one_inferior_data data
;
971 data
.recurse
= recurse
;
972 data
.inferiors
= ids
;
974 /* Local thread groups. Either no explicit ids -- and we
975 print everything, or several explicit ids. In both cases,
976 we print more than one group, and have to use 'groups'
977 as the top-level element. */
978 make_cleanup_ui_out_list_begin_end (uiout
, "groups");
979 update_thread_list ();
980 iterate_over_inferiors (print_one_inferior
, &data
);
983 do_cleanups (back_to
);
987 mi_cmd_data_list_register_names (const char *command
, char **argv
, int argc
)
989 struct gdbarch
*gdbarch
;
990 struct ui_out
*uiout
= current_uiout
;
994 /* Note that the test for a valid register must include checking the
995 gdbarch_register_name because gdbarch_num_regs may be allocated
996 for the union of the register sets within a family of related
997 processors. In this case, some entries of gdbarch_register_name
998 will change depending upon the particular processor being
1001 gdbarch
= get_current_arch ();
1002 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1004 ui_out_emit_list
list_emitter (uiout
, "register-names");
1006 if (argc
== 0) /* No args, just do all the regs. */
1012 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1013 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1014 uiout
->field_string (NULL
, "");
1016 uiout
->field_string (NULL
, gdbarch_register_name (gdbarch
, regnum
));
1020 /* Else, list of register #s, just do listed regs. */
1021 for (i
= 0; i
< argc
; i
++)
1023 regnum
= atoi (argv
[i
]);
1024 if (regnum
< 0 || regnum
>= numregs
)
1025 error (_("bad register number"));
1027 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1028 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1029 uiout
->field_string (NULL
, "");
1031 uiout
->field_string (NULL
, gdbarch_register_name (gdbarch
, regnum
));
1036 mi_cmd_data_list_changed_registers (const char *command
, char **argv
, int argc
)
1038 static struct regcache
*this_regs
= NULL
;
1039 struct ui_out
*uiout
= current_uiout
;
1040 struct regcache
*prev_regs
;
1041 struct gdbarch
*gdbarch
;
1042 int regnum
, numregs
, changed
;
1044 struct cleanup
*cleanup
;
1046 /* The last time we visited this function, the current frame's
1047 register contents were saved in THIS_REGS. Move THIS_REGS over
1048 to PREV_REGS, and refresh THIS_REGS with the now-current register
1051 prev_regs
= this_regs
;
1052 this_regs
= frame_save_as_regcache (get_selected_frame (NULL
));
1053 cleanup
= make_cleanup_regcache_xfree (prev_regs
);
1055 /* Note that the test for a valid register must include checking the
1056 gdbarch_register_name because gdbarch_num_regs may be allocated
1057 for the union of the register sets within a family of related
1058 processors. In this case, some entries of gdbarch_register_name
1059 will change depending upon the particular processor being
1062 gdbarch
= get_regcache_arch (this_regs
);
1063 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1065 make_cleanup_ui_out_list_begin_end (uiout
, "changed-registers");
1069 /* No args, just do all the regs. */
1074 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1075 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1077 changed
= register_changed_p (regnum
, prev_regs
, this_regs
);
1079 error (_("-data-list-changed-registers: "
1080 "Unable to read register contents."));
1082 uiout
->field_int (NULL
, regnum
);
1086 /* Else, list of register #s, just do listed regs. */
1087 for (i
= 0; i
< argc
; i
++)
1089 regnum
= atoi (argv
[i
]);
1093 && gdbarch_register_name (gdbarch
, regnum
) != NULL
1094 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
1096 changed
= register_changed_p (regnum
, prev_regs
, this_regs
);
1098 error (_("-data-list-changed-registers: "
1099 "Unable to read register contents."));
1101 uiout
->field_int (NULL
, regnum
);
1104 error (_("bad register number"));
1106 do_cleanups (cleanup
);
1110 register_changed_p (int regnum
, struct regcache
*prev_regs
,
1111 struct regcache
*this_regs
)
1113 struct gdbarch
*gdbarch
= get_regcache_arch (this_regs
);
1114 struct value
*prev_value
, *this_value
;
1117 /* First time through or after gdbarch change consider all registers
1119 if (!prev_regs
|| get_regcache_arch (prev_regs
) != gdbarch
)
1122 /* Get register contents and compare. */
1123 prev_value
= prev_regs
->cooked_read_value (regnum
);
1124 this_value
= this_regs
->cooked_read_value (regnum
);
1125 gdb_assert (prev_value
!= NULL
);
1126 gdb_assert (this_value
!= NULL
);
1128 ret
= value_contents_eq (prev_value
, 0, this_value
, 0,
1129 register_size (gdbarch
, regnum
)) == 0;
1131 release_value (prev_value
);
1132 release_value (this_value
);
1133 value_free (prev_value
);
1134 value_free (this_value
);
1138 /* Return a list of register number and value pairs. The valid
1139 arguments expected are: a letter indicating the format in which to
1140 display the registers contents. This can be one of: x
1141 (hexadecimal), d (decimal), N (natural), t (binary), o (octal), r
1142 (raw). After the format argument there can be a sequence of
1143 numbers, indicating which registers to fetch the content of. If
1144 the format is the only argument, a list of all the registers with
1145 their values is returned. */
1148 mi_cmd_data_list_register_values (const char *command
, char **argv
, int argc
)
1150 struct ui_out
*uiout
= current_uiout
;
1151 struct frame_info
*frame
;
1152 struct gdbarch
*gdbarch
;
1153 int regnum
, numregs
, format
;
1155 int skip_unavailable
= 0;
1161 static const struct mi_opt opts
[] =
1163 {"-skip-unavailable", SKIP_UNAVAILABLE
, 0},
1167 /* Note that the test for a valid register must include checking the
1168 gdbarch_register_name because gdbarch_num_regs may be allocated
1169 for the union of the register sets within a family of related
1170 processors. In this case, some entries of gdbarch_register_name
1171 will change depending upon the particular processor being
1177 int opt
= mi_getopt ("-data-list-register-values", argc
, argv
,
1178 opts
, &oind
, &oarg
);
1182 switch ((enum opt
) opt
)
1184 case SKIP_UNAVAILABLE
:
1185 skip_unavailable
= 1;
1190 if (argc
- oind
< 1)
1191 error (_("-data-list-register-values: Usage: "
1192 "-data-list-register-values [--skip-unavailable] <format>"
1193 " [<regnum1>...<regnumN>]"));
1195 format
= (int) argv
[oind
][0];
1197 frame
= get_selected_frame (NULL
);
1198 gdbarch
= get_frame_arch (frame
);
1199 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1201 ui_out_emit_list
list_emitter (uiout
, "register-values");
1203 if (argc
- oind
== 1)
1205 /* No args, beside the format: do all the regs. */
1210 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1211 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1214 output_register (frame
, regnum
, format
, skip_unavailable
);
1218 /* Else, list of register #s, just do listed regs. */
1219 for (i
= 1 + oind
; i
< argc
; i
++)
1221 regnum
= atoi (argv
[i
]);
1225 && gdbarch_register_name (gdbarch
, regnum
) != NULL
1226 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
1227 output_register (frame
, regnum
, format
, skip_unavailable
);
1229 error (_("bad register number"));
1233 /* Output one register REGNUM's contents in the desired FORMAT. If
1234 SKIP_UNAVAILABLE is true, skip the register if it is
1238 output_register (struct frame_info
*frame
, int regnum
, int format
,
1239 int skip_unavailable
)
1241 struct ui_out
*uiout
= current_uiout
;
1242 struct value
*val
= value_of_register (regnum
, frame
);
1243 struct value_print_options opts
;
1245 if (skip_unavailable
&& !value_entirely_available (val
))
1248 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1249 uiout
->field_int ("number", regnum
);
1259 get_formatted_print_options (&opts
, format
);
1261 val_print (value_type (val
),
1262 value_embedded_offset (val
), 0,
1263 &stb
, 0, val
, &opts
, current_language
);
1264 uiout
->field_stream ("value", stb
);
1267 /* Write given values into registers. The registers and values are
1268 given as pairs. The corresponding MI command is
1269 -data-write-register-values <format>
1270 [<regnum1> <value1>...<regnumN> <valueN>] */
1272 mi_cmd_data_write_register_values (const char *command
, char **argv
, int argc
)
1274 struct regcache
*regcache
;
1275 struct gdbarch
*gdbarch
;
1278 /* Note that the test for a valid register must include checking the
1279 gdbarch_register_name because gdbarch_num_regs may be allocated
1280 for the union of the register sets within a family of related
1281 processors. In this case, some entries of gdbarch_register_name
1282 will change depending upon the particular processor being
1285 regcache
= get_current_regcache ();
1286 gdbarch
= get_regcache_arch (regcache
);
1287 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1290 error (_("-data-write-register-values: Usage: -data-write-register-"
1291 "values <format> [<regnum1> <value1>...<regnumN> <valueN>]"));
1293 if (!target_has_registers
)
1294 error (_("-data-write-register-values: No registers."));
1297 error (_("-data-write-register-values: No regs and values specified."));
1300 error (_("-data-write-register-values: "
1301 "Regs and vals are not in pairs."));
1303 for (i
= 1; i
< argc
; i
= i
+ 2)
1305 int regnum
= atoi (argv
[i
]);
1307 if (regnum
>= 0 && regnum
< numregs
1308 && gdbarch_register_name (gdbarch
, regnum
)
1309 && *gdbarch_register_name (gdbarch
, regnum
))
1313 /* Get the value as a number. */
1314 value
= parse_and_eval_address (argv
[i
+ 1]);
1316 /* Write it down. */
1317 regcache_cooked_write_signed (regcache
, regnum
, value
);
1320 error (_("bad register number"));
1324 /* Evaluate the value of the argument. The argument is an
1325 expression. If the expression contains spaces it needs to be
1326 included in double quotes. */
1329 mi_cmd_data_evaluate_expression (const char *command
, char **argv
, int argc
)
1332 struct value_print_options opts
;
1333 struct ui_out
*uiout
= current_uiout
;
1336 error (_("-data-evaluate-expression: "
1337 "Usage: -data-evaluate-expression expression"));
1339 expression_up expr
= parse_expression (argv
[0]);
1341 val
= evaluate_expression (expr
.get ());
1345 /* Print the result of the expression evaluation. */
1346 get_user_print_options (&opts
);
1348 common_val_print (val
, &stb
, 0, &opts
, current_language
);
1350 uiout
->field_stream ("value", stb
);
1353 /* This is the -data-read-memory command.
1355 ADDR: start address of data to be dumped.
1356 WORD-FORMAT: a char indicating format for the ``word''. See
1358 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
1359 NR_ROW: Number of rows.
1360 NR_COL: The number of colums (words per row).
1361 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
1362 ASCHAR for unprintable characters.
1364 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
1365 displayes them. Returns:
1367 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
1370 The number of bytes read is SIZE*ROW*COL. */
1373 mi_cmd_data_read_memory (const char *command
, char **argv
, int argc
)
1375 struct gdbarch
*gdbarch
= get_current_arch ();
1376 struct ui_out
*uiout
= current_uiout
;
1378 long total_bytes
, nr_cols
, nr_rows
;
1380 struct type
*word_type
;
1392 static const struct mi_opt opts
[] =
1394 {"o", OFFSET_OPT
, 1},
1400 int opt
= mi_getopt ("-data-read-memory", argc
, argv
, opts
,
1405 switch ((enum opt
) opt
)
1408 offset
= atol (oarg
);
1415 if (argc
< 5 || argc
> 6)
1416 error (_("-data-read-memory: Usage: "
1417 "ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR]."));
1419 /* Extract all the arguments. */
1421 /* Start address of the memory dump. */
1422 addr
= parse_and_eval_address (argv
[0]) + offset
;
1423 /* The format character to use when displaying a memory word. See
1424 the ``x'' command. */
1425 word_format
= argv
[1][0];
1426 /* The size of the memory word. */
1427 word_size
= atol (argv
[2]);
1431 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1435 word_type
= builtin_type (gdbarch
)->builtin_int16
;
1439 word_type
= builtin_type (gdbarch
)->builtin_int32
;
1443 word_type
= builtin_type (gdbarch
)->builtin_int64
;
1447 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1450 /* The number of rows. */
1451 nr_rows
= atol (argv
[3]);
1453 error (_("-data-read-memory: invalid number of rows."));
1455 /* Number of bytes per row. */
1456 nr_cols
= atol (argv
[4]);
1458 error (_("-data-read-memory: invalid number of columns."));
1460 /* The un-printable character when printing ascii. */
1466 /* Create a buffer and read it in. */
1467 total_bytes
= word_size
* nr_rows
* nr_cols
;
1469 gdb::byte_vector
mbuf (total_bytes
);
1471 /* Dispatch memory reads to the topmost target, not the flattened
1473 nr_bytes
= target_read (current_target
.beneath
,
1474 TARGET_OBJECT_MEMORY
, NULL
, mbuf
.data (),
1477 error (_("Unable to read memory."));
1479 /* Output the header information. */
1480 uiout
->field_core_addr ("addr", gdbarch
, addr
);
1481 uiout
->field_int ("nr-bytes", nr_bytes
);
1482 uiout
->field_int ("total-bytes", total_bytes
);
1483 uiout
->field_core_addr ("next-row", gdbarch
, addr
+ word_size
* nr_cols
);
1484 uiout
->field_core_addr ("prev-row", gdbarch
, addr
- word_size
* nr_cols
);
1485 uiout
->field_core_addr ("next-page", gdbarch
, addr
+ total_bytes
);
1486 uiout
->field_core_addr ("prev-page", gdbarch
, addr
- total_bytes
);
1488 /* Build the result as a two dimentional table. */
1492 struct cleanup
*cleanup_list
;
1496 cleanup_list
= make_cleanup_ui_out_list_begin_end (uiout
, "memory");
1497 for (row
= 0, row_byte
= 0;
1499 row
++, row_byte
+= nr_cols
* word_size
)
1503 struct cleanup
*cleanup_list_data
;
1504 struct value_print_options opts
;
1506 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1507 uiout
->field_core_addr ("addr", gdbarch
, addr
+ row_byte
);
1508 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr +
1510 cleanup_list_data
= make_cleanup_ui_out_list_begin_end (uiout
, "data");
1511 get_formatted_print_options (&opts
, word_format
);
1512 for (col
= 0, col_byte
= row_byte
;
1514 col
++, col_byte
+= word_size
)
1516 if (col_byte
+ word_size
> nr_bytes
)
1518 uiout
->field_string (NULL
, "N/A");
1523 print_scalar_formatted (&mbuf
[col_byte
], word_type
, &opts
,
1524 word_asize
, &stream
);
1525 uiout
->field_stream (NULL
, stream
);
1528 do_cleanups (cleanup_list_data
);
1534 for (byte
= row_byte
;
1535 byte
< row_byte
+ word_size
* nr_cols
; byte
++)
1537 if (byte
>= nr_bytes
)
1539 else if (mbuf
[byte
] < 32 || mbuf
[byte
] > 126)
1540 stream
.putc (aschar
);
1542 stream
.putc (mbuf
[byte
]);
1544 uiout
->field_stream ("ascii", stream
);
1547 do_cleanups (cleanup_list
);
1552 mi_cmd_data_read_memory_bytes (const char *command
, char **argv
, int argc
)
1554 struct gdbarch
*gdbarch
= get_current_arch ();
1555 struct ui_out
*uiout
= current_uiout
;
1556 struct cleanup
*cleanups
;
1559 memory_read_result_s
*read_result
;
1561 VEC(memory_read_result_s
) *result
;
1563 int unit_size
= gdbarch_addressable_memory_unit_size (gdbarch
);
1570 static const struct mi_opt opts
[] =
1572 {"o", OFFSET_OPT
, 1},
1578 int opt
= mi_getopt ("-data-read-memory-bytes", argc
, argv
, opts
,
1582 switch ((enum opt
) opt
)
1585 offset
= atol (oarg
);
1593 error (_("Usage: [ -o OFFSET ] ADDR LENGTH."));
1595 addr
= parse_and_eval_address (argv
[0]) + offset
;
1596 length
= atol (argv
[1]);
1598 result
= read_memory_robust (current_target
.beneath
, addr
, length
);
1600 cleanups
= make_cleanup (free_memory_read_result_vector
, &result
);
1602 if (VEC_length (memory_read_result_s
, result
) == 0)
1603 error (_("Unable to read memory."));
1605 make_cleanup_ui_out_list_begin_end (uiout
, "memory");
1607 VEC_iterate (memory_read_result_s
, result
, ix
, read_result
);
1610 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1615 uiout
->field_core_addr ("begin", gdbarch
, read_result
->begin
);
1616 uiout
->field_core_addr ("offset", gdbarch
, read_result
->begin
- addr
);
1617 uiout
->field_core_addr ("end", gdbarch
, read_result
->end
);
1619 alloc_len
= (read_result
->end
- read_result
->begin
) * 2 * unit_size
+ 1;
1620 data
= (char *) xmalloc (alloc_len
);
1622 for (i
= 0, p
= data
;
1623 i
< ((read_result
->end
- read_result
->begin
) * unit_size
);
1626 sprintf (p
, "%02x", read_result
->data
[i
]);
1628 uiout
->field_string ("contents", data
);
1631 do_cleanups (cleanups
);
1634 /* Implementation of the -data-write_memory command.
1636 COLUMN_OFFSET: optional argument. Must be preceded by '-o'. The
1637 offset from the beginning of the memory grid row where the cell to
1639 ADDR: start address of the row in the memory grid where the memory
1640 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
1641 the location to write to.
1642 FORMAT: a char indicating format for the ``word''. See
1644 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
1645 VALUE: value to be written into the memory address.
1647 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1652 mi_cmd_data_write_memory (const char *command
, char **argv
, int argc
)
1654 struct gdbarch
*gdbarch
= get_current_arch ();
1655 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1658 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1659 enough when using a compiler other than GCC. */
1668 static const struct mi_opt opts
[] =
1670 {"o", OFFSET_OPT
, 1},
1676 int opt
= mi_getopt ("-data-write-memory", argc
, argv
, opts
,
1681 switch ((enum opt
) opt
)
1684 offset
= atol (oarg
);
1692 error (_("-data-write-memory: Usage: "
1693 "[-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE."));
1695 /* Extract all the arguments. */
1696 /* Start address of the memory dump. */
1697 addr
= parse_and_eval_address (argv
[0]);
1698 /* The size of the memory word. */
1699 word_size
= atol (argv
[2]);
1701 /* Calculate the real address of the write destination. */
1702 addr
+= (offset
* word_size
);
1704 /* Get the value as a number. */
1705 value
= parse_and_eval_address (argv
[3]);
1706 /* Get the value into an array. */
1707 gdb::byte_vector
buffer (word_size
);
1708 store_signed_integer (buffer
.data (), word_size
, byte_order
, value
);
1709 /* Write it down to memory. */
1710 write_memory_with_notification (addr
, buffer
.data (), word_size
);
1713 /* Implementation of the -data-write-memory-bytes command.
1716 DATA: string of bytes to write at that address
1717 COUNT: number of bytes to be filled (decimal integer). */
1720 mi_cmd_data_write_memory_bytes (const char *command
, char **argv
, int argc
)
1726 size_t len_hex
, len_bytes
, len_units
, i
, steps
, remaining_units
;
1727 long int count_units
;
1728 struct cleanup
*back_to
;
1731 if (argc
!= 2 && argc
!= 3)
1732 error (_("Usage: ADDR DATA [COUNT]."));
1734 addr
= parse_and_eval_address (argv
[0]);
1736 len_hex
= strlen (cdata
);
1737 unit_size
= gdbarch_addressable_memory_unit_size (get_current_arch ());
1739 if (len_hex
% (unit_size
* 2) != 0)
1740 error (_("Hex-encoded '%s' must represent an integral number of "
1741 "addressable memory units."),
1744 len_bytes
= len_hex
/ 2;
1745 len_units
= len_bytes
/ unit_size
;
1748 count_units
= strtoul (argv
[2], NULL
, 10);
1750 count_units
= len_units
;
1752 databuf
= XNEWVEC (gdb_byte
, len_bytes
);
1753 back_to
= make_cleanup (xfree
, databuf
);
1755 for (i
= 0; i
< len_bytes
; ++i
)
1758 if (sscanf (cdata
+ i
* 2, "%02x", &x
) != 1)
1759 error (_("Invalid argument"));
1760 databuf
[i
] = (gdb_byte
) x
;
1763 if (len_units
< count_units
)
1765 /* Pattern is made of less units than count:
1766 repeat pattern to fill memory. */
1767 data
= (gdb_byte
*) xmalloc (count_units
* unit_size
);
1768 make_cleanup (xfree
, data
);
1770 /* Number of times the pattern is entirely repeated. */
1771 steps
= count_units
/ len_units
;
1772 /* Number of remaining addressable memory units. */
1773 remaining_units
= count_units
% len_units
;
1774 for (i
= 0; i
< steps
; i
++)
1775 memcpy (data
+ i
* len_bytes
, databuf
, len_bytes
);
1777 if (remaining_units
> 0)
1778 memcpy (data
+ steps
* len_bytes
, databuf
,
1779 remaining_units
* unit_size
);
1783 /* Pattern is longer than or equal to count:
1784 just copy count addressable memory units. */
1788 write_memory_with_notification (addr
, data
, count_units
);
1790 do_cleanups (back_to
);
1794 mi_cmd_enable_timings (const char *command
, char **argv
, int argc
)
1800 if (strcmp (argv
[0], "yes") == 0)
1802 else if (strcmp (argv
[0], "no") == 0)
1813 error (_("-enable-timings: Usage: %s {yes|no}"), command
);
1817 mi_cmd_list_features (const char *command
, char **argv
, int argc
)
1821 struct ui_out
*uiout
= current_uiout
;
1823 ui_out_emit_list
list_emitter (uiout
, "features");
1824 uiout
->field_string (NULL
, "frozen-varobjs");
1825 uiout
->field_string (NULL
, "pending-breakpoints");
1826 uiout
->field_string (NULL
, "thread-info");
1827 uiout
->field_string (NULL
, "data-read-memory-bytes");
1828 uiout
->field_string (NULL
, "breakpoint-notifications");
1829 uiout
->field_string (NULL
, "ada-task-info");
1830 uiout
->field_string (NULL
, "language-option");
1831 uiout
->field_string (NULL
, "info-gdb-mi-command");
1832 uiout
->field_string (NULL
, "undefined-command-error-code");
1833 uiout
->field_string (NULL
, "exec-run-start-option");
1835 if (ext_lang_initialized_p (get_ext_lang_defn (EXT_LANG_PYTHON
)))
1836 uiout
->field_string (NULL
, "python");
1841 error (_("-list-features should be passed no arguments"));
1845 mi_cmd_list_target_features (const char *command
, char **argv
, int argc
)
1849 struct ui_out
*uiout
= current_uiout
;
1851 ui_out_emit_list
list_emitter (uiout
, "features");
1853 uiout
->field_string (NULL
, "async");
1854 if (target_can_execute_reverse
)
1855 uiout
->field_string (NULL
, "reverse");
1859 error (_("-list-target-features should be passed no arguments"));
1863 mi_cmd_add_inferior (const char *command
, char **argv
, int argc
)
1865 struct inferior
*inf
;
1868 error (_("-add-inferior should be passed no arguments"));
1870 inf
= add_inferior_with_spaces ();
1872 current_uiout
->field_fmt ("inferior", "i%d", inf
->num
);
1875 /* Callback used to find the first inferior other than the current
1879 get_other_inferior (struct inferior
*inf
, void *arg
)
1881 if (inf
== current_inferior ())
1888 mi_cmd_remove_inferior (const char *command
, char **argv
, int argc
)
1891 struct inferior
*inf
;
1894 error (_("-remove-inferior should be passed a single argument"));
1896 if (sscanf (argv
[0], "i%d", &id
) != 1)
1897 error (_("the thread group id is syntactically invalid"));
1899 inf
= find_inferior_id (id
);
1901 error (_("the specified thread group does not exist"));
1904 error (_("cannot remove an active inferior"));
1906 if (inf
== current_inferior ())
1908 struct thread_info
*tp
= 0;
1909 struct inferior
*new_inferior
1910 = iterate_over_inferiors (get_other_inferior
, NULL
);
1912 if (new_inferior
== NULL
)
1913 error (_("Cannot remove last inferior"));
1915 set_current_inferior (new_inferior
);
1916 if (new_inferior
->pid
!= 0)
1917 tp
= any_thread_of_process (new_inferior
->pid
);
1918 switch_to_thread (tp
? tp
->ptid
: null_ptid
);
1919 set_current_program_space (new_inferior
->pspace
);
1922 delete_inferior (inf
);
1927 /* Execute a command within a safe environment.
1928 Return <0 for error; >=0 for ok.
1930 args->action will tell mi_execute_command what action
1931 to perfrom after the given command has executed (display/suppress
1932 prompt, display error). */
1935 captured_mi_execute_command (struct ui_out
*uiout
, struct mi_parse
*context
)
1937 struct mi_interp
*mi
= (struct mi_interp
*) command_interp ();
1938 struct cleanup
*cleanup
;
1941 current_command_ts
= context
->cmd_start
;
1943 current_token
= xstrdup (context
->token
);
1944 cleanup
= make_cleanup (free_current_contents
, ¤t_token
);
1946 running_result_record_printed
= 0;
1948 switch (context
->op
)
1951 /* A MI command was read from the input stream. */
1953 /* FIXME: gdb_???? */
1954 fprintf_unfiltered (mi
->raw_stdout
,
1955 " token=`%s' command=`%s' args=`%s'\n",
1956 context
->token
, context
->command
, context
->args
);
1958 mi_cmd_execute (context
);
1960 /* Print the result if there were no errors.
1962 Remember that on the way out of executing a command, you have
1963 to directly use the mi_interp's uiout, since the command
1964 could have reset the interpreter, in which case the current
1965 uiout will most likely crash in the mi_out_* routines. */
1966 if (!running_result_record_printed
)
1968 fputs_unfiltered (context
->token
, mi
->raw_stdout
);
1969 /* There's no particularly good reason why target-connect results
1970 in not ^done. Should kill ^connected for MI3. */
1971 fputs_unfiltered (strcmp (context
->command
, "target-select") == 0
1972 ? "^connected" : "^done", mi
->raw_stdout
);
1973 mi_out_put (uiout
, mi
->raw_stdout
);
1974 mi_out_rewind (uiout
);
1975 mi_print_timing_maybe (mi
->raw_stdout
);
1976 fputs_unfiltered ("\n", mi
->raw_stdout
);
1979 /* The command does not want anything to be printed. In that
1980 case, the command probably should not have written anything
1981 to uiout, but in case it has written something, discard it. */
1982 mi_out_rewind (uiout
);
1989 /* A CLI command was read from the input stream. */
1990 /* This "feature" will be removed as soon as we have a
1991 complete set of mi commands. */
1992 /* Echo the command on the console. */
1993 fprintf_unfiltered (gdb_stdlog
, "%s\n", context
->command
);
1994 /* Call the "console" interpreter. */
1995 argv
[0] = (char *) INTERP_CONSOLE
;
1996 argv
[1] = context
->command
;
1997 mi_cmd_interpreter_exec ("-interpreter-exec", argv
, 2);
1999 /* If we changed interpreters, DON'T print out anything. */
2000 if (current_interp_named_p (INTERP_MI
)
2001 || current_interp_named_p (INTERP_MI1
)
2002 || current_interp_named_p (INTERP_MI2
)
2003 || current_interp_named_p (INTERP_MI3
))
2005 if (!running_result_record_printed
)
2007 fputs_unfiltered (context
->token
, mi
->raw_stdout
);
2008 fputs_unfiltered ("^done", mi
->raw_stdout
);
2009 mi_out_put (uiout
, mi
->raw_stdout
);
2010 mi_out_rewind (uiout
);
2011 mi_print_timing_maybe (mi
->raw_stdout
);
2012 fputs_unfiltered ("\n", mi
->raw_stdout
);
2015 mi_out_rewind (uiout
);
2021 do_cleanups (cleanup
);
2024 /* Print a gdb exception to the MI output stream. */
2027 mi_print_exception (const char *token
, struct gdb_exception exception
)
2029 struct mi_interp
*mi
= (struct mi_interp
*) current_interpreter ();
2031 fputs_unfiltered (token
, mi
->raw_stdout
);
2032 fputs_unfiltered ("^error,msg=\"", mi
->raw_stdout
);
2033 if (exception
.message
== NULL
)
2034 fputs_unfiltered ("unknown error", mi
->raw_stdout
);
2036 fputstr_unfiltered (exception
.message
, '"', mi
->raw_stdout
);
2037 fputs_unfiltered ("\"", mi
->raw_stdout
);
2039 switch (exception
.error
)
2041 case UNDEFINED_COMMAND_ERROR
:
2042 fputs_unfiltered (",code=\"undefined-command\"", mi
->raw_stdout
);
2046 fputs_unfiltered ("\n", mi
->raw_stdout
);
2049 /* Determine whether the parsed command already notifies the
2050 user_selected_context_changed observer. */
2053 command_notifies_uscc_observer (struct mi_parse
*command
)
2055 if (command
->op
== CLI_COMMAND
)
2057 /* CLI commands "thread" and "inferior" already send it. */
2058 return (strncmp (command
->command
, "thread ", 7) == 0
2059 || strncmp (command
->command
, "inferior ", 9) == 0);
2061 else /* MI_COMMAND */
2063 if (strcmp (command
->command
, "interpreter-exec") == 0
2064 && command
->argc
> 1)
2066 /* "thread" and "inferior" again, but through -interpreter-exec. */
2067 return (strncmp (command
->argv
[1], "thread ", 7) == 0
2068 || strncmp (command
->argv
[1], "inferior ", 9) == 0);
2072 /* -thread-select already sends it. */
2073 return strcmp (command
->command
, "thread-select") == 0;
2078 mi_execute_command (const char *cmd
, int from_tty
)
2081 std::unique_ptr
<struct mi_parse
> command
;
2083 /* This is to handle EOF (^D). We just quit gdb. */
2084 /* FIXME: we should call some API function here. */
2086 quit_force (NULL
, from_tty
);
2088 target_log_command (cmd
);
2092 command
= mi_parse (cmd
, &token
);
2094 CATCH (exception
, RETURN_MASK_ALL
)
2096 mi_print_exception (token
, exception
);
2101 if (command
!= NULL
)
2103 ptid_t previous_ptid
= inferior_ptid
;
2105 gdb::optional
<scoped_restore_tmpl
<int>> restore_suppress
;
2107 if (command
->cmd
!= NULL
&& command
->cmd
->suppress_notification
!= NULL
)
2108 restore_suppress
.emplace (command
->cmd
->suppress_notification
, 1);
2110 command
->token
= token
;
2114 command
->cmd_start
= new mi_timestamp ();
2115 timestamp (command
->cmd_start
);
2120 captured_mi_execute_command (current_uiout
, command
.get ());
2122 CATCH (result
, RETURN_MASK_ALL
)
2124 /* Like in start_event_loop, enable input and force display
2125 of the prompt. Otherwise, any command that calls
2126 async_disable_stdin, and then throws, will leave input
2128 async_enable_stdin ();
2129 current_ui
->prompt_state
= PROMPT_NEEDED
;
2131 /* The command execution failed and error() was called
2133 mi_print_exception (command
->token
, result
);
2134 mi_out_rewind (current_uiout
);
2138 bpstat_do_actions ();
2140 if (/* The notifications are only output when the top-level
2141 interpreter (specified on the command line) is MI. */
2142 interp_ui_out (top_level_interpreter ())->is_mi_like_p ()
2143 /* Don't try report anything if there are no threads --
2144 the program is dead. */
2145 && thread_count () != 0
2146 /* If the command already reports the thread change, no need to do it
2148 && !command_notifies_uscc_observer (command
.get ()))
2150 struct mi_interp
*mi
= (struct mi_interp
*) top_level_interpreter ();
2151 int report_change
= 0;
2153 if (command
->thread
== -1)
2155 report_change
= (!ptid_equal (previous_ptid
, null_ptid
)
2156 && !ptid_equal (inferior_ptid
, previous_ptid
)
2157 && !ptid_equal (inferior_ptid
, null_ptid
));
2159 else if (!ptid_equal (inferior_ptid
, null_ptid
))
2161 struct thread_info
*ti
= inferior_thread ();
2163 report_change
= (ti
->global_num
!= command
->thread
);
2168 observer_notify_user_selected_context_changed
2169 (USER_SELECTED_THREAD
| USER_SELECTED_FRAME
);
2176 mi_cmd_execute (struct mi_parse
*parse
)
2178 struct cleanup
*cleanup
;
2180 cleanup
= prepare_execute_command ();
2182 if (parse
->all
&& parse
->thread_group
!= -1)
2183 error (_("Cannot specify --thread-group together with --all"));
2185 if (parse
->all
&& parse
->thread
!= -1)
2186 error (_("Cannot specify --thread together with --all"));
2188 if (parse
->thread_group
!= -1 && parse
->thread
!= -1)
2189 error (_("Cannot specify --thread together with --thread-group"));
2191 if (parse
->frame
!= -1 && parse
->thread
== -1)
2192 error (_("Cannot specify --frame without --thread"));
2194 if (parse
->thread_group
!= -1)
2196 struct inferior
*inf
= find_inferior_id (parse
->thread_group
);
2197 struct thread_info
*tp
= 0;
2200 error (_("Invalid thread group for the --thread-group option"));
2202 set_current_inferior (inf
);
2203 /* This behaviour means that if --thread-group option identifies
2204 an inferior with multiple threads, then a random one will be
2205 picked. This is not a problem -- frontend should always
2206 provide --thread if it wishes to operate on a specific
2209 tp
= any_live_thread_of_process (inf
->pid
);
2210 switch_to_thread (tp
? tp
->ptid
: null_ptid
);
2211 set_current_program_space (inf
->pspace
);
2214 if (parse
->thread
!= -1)
2216 struct thread_info
*tp
= find_thread_global_id (parse
->thread
);
2219 error (_("Invalid thread id: %d"), parse
->thread
);
2221 if (is_exited (tp
->ptid
))
2222 error (_("Thread id: %d has terminated"), parse
->thread
);
2224 switch_to_thread (tp
->ptid
);
2227 if (parse
->frame
!= -1)
2229 struct frame_info
*fid
;
2230 int frame
= parse
->frame
;
2232 fid
= find_relative_frame (get_current_frame (), &frame
);
2234 /* find_relative_frame was successful */
2237 error (_("Invalid frame id: %d"), frame
);
2240 gdb::optional
<scoped_restore_current_language
> lang_saver
;
2241 if (parse
->language
!= language_unknown
)
2243 lang_saver
.emplace ();
2244 set_language (parse
->language
);
2247 current_context
= parse
;
2249 if (parse
->cmd
->argv_func
!= NULL
)
2251 parse
->cmd
->argv_func (parse
->command
, parse
->argv
, parse
->argc
);
2253 else if (parse
->cmd
->cli
.cmd
!= 0)
2255 /* FIXME: DELETE THIS. */
2256 /* The operation is still implemented by a cli command. */
2257 /* Must be a synchronous one. */
2258 mi_execute_cli_command (parse
->cmd
->cli
.cmd
, parse
->cmd
->cli
.args_p
,
2263 /* FIXME: DELETE THIS. */
2266 stb
.puts ("Undefined mi command: ");
2267 stb
.putstr (parse
->command
, '"');
2268 stb
.puts (" (missing implementation)");
2272 do_cleanups (cleanup
);
2275 /* FIXME: This is just a hack so we can get some extra commands going.
2276 We don't want to channel things through the CLI, but call libgdb directly.
2277 Use only for synchronous commands. */
2280 mi_execute_cli_command (const char *cmd
, int args_p
, const char *args
)
2284 struct cleanup
*old_cleanups
;
2288 run
= xstrprintf ("%s %s", cmd
, args
);
2290 run
= xstrdup (cmd
);
2292 /* FIXME: gdb_???? */
2293 fprintf_unfiltered (gdb_stdout
, "cli=%s run=%s\n",
2295 old_cleanups
= make_cleanup (xfree
, run
);
2296 execute_command (run
, 0 /* from_tty */ );
2297 do_cleanups (old_cleanups
);
2303 mi_execute_async_cli_command (const char *cli_command
, char **argv
, int argc
)
2305 struct cleanup
*old_cleanups
;
2309 run
= xstrprintf ("%s %s&", cli_command
, argc
? *argv
: "");
2311 run
= xstrprintf ("%s %s", cli_command
, argc
? *argv
: "");
2312 old_cleanups
= make_cleanup (xfree
, run
);
2314 execute_command (run
, 0 /* from_tty */ );
2316 /* Do this before doing any printing. It would appear that some
2317 print code leaves garbage around in the buffer. */
2318 do_cleanups (old_cleanups
);
2322 mi_load_progress (const char *section_name
,
2323 unsigned long sent_so_far
,
2324 unsigned long total_section
,
2325 unsigned long total_sent
,
2326 unsigned long grand_total
)
2328 using namespace std::chrono
;
2329 static steady_clock::time_point last_update
;
2330 static char *previous_sect_name
= NULL
;
2332 struct ui_out
*saved_uiout
;
2333 struct ui_out
*uiout
;
2334 struct mi_interp
*mi
= (struct mi_interp
*) current_interpreter ();
2336 /* This function is called through deprecated_show_load_progress
2337 which means uiout may not be correct. Fix it for the duration
2338 of this function. */
2339 saved_uiout
= current_uiout
;
2341 if (current_interp_named_p (INTERP_MI
)
2342 || current_interp_named_p (INTERP_MI2
))
2343 current_uiout
= mi_out_new (2);
2344 else if (current_interp_named_p (INTERP_MI1
))
2345 current_uiout
= mi_out_new (1);
2346 else if (current_interp_named_p (INTERP_MI3
))
2347 current_uiout
= mi_out_new (3);
2351 uiout
= current_uiout
;
2353 new_section
= (previous_sect_name
?
2354 strcmp (previous_sect_name
, section_name
) : 1);
2357 xfree (previous_sect_name
);
2358 previous_sect_name
= xstrdup (section_name
);
2361 fputs_unfiltered (current_token
, mi
->raw_stdout
);
2362 fputs_unfiltered ("+download", mi
->raw_stdout
);
2364 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
2365 uiout
->field_string ("section", section_name
);
2366 uiout
->field_int ("section-size", total_section
);
2367 uiout
->field_int ("total-size", grand_total
);
2369 mi_out_put (uiout
, mi
->raw_stdout
);
2370 fputs_unfiltered ("\n", mi
->raw_stdout
);
2371 gdb_flush (mi
->raw_stdout
);
2374 steady_clock::time_point time_now
= steady_clock::now ();
2375 if (time_now
- last_update
> milliseconds (500))
2377 last_update
= time_now
;
2379 fputs_unfiltered (current_token
, mi
->raw_stdout
);
2380 fputs_unfiltered ("+download", mi
->raw_stdout
);
2382 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
2383 uiout
->field_string ("section", section_name
);
2384 uiout
->field_int ("section-sent", sent_so_far
);
2385 uiout
->field_int ("section-size", total_section
);
2386 uiout
->field_int ("total-sent", total_sent
);
2387 uiout
->field_int ("total-size", grand_total
);
2389 mi_out_put (uiout
, mi
->raw_stdout
);
2390 fputs_unfiltered ("\n", mi
->raw_stdout
);
2391 gdb_flush (mi
->raw_stdout
);
2395 current_uiout
= saved_uiout
;
2399 timestamp (struct mi_timestamp
*tv
)
2401 using namespace std::chrono
;
2403 tv
->wallclock
= steady_clock::now ();
2404 run_time_clock::now (tv
->utime
, tv
->stime
);
2408 print_diff_now (struct ui_file
*file
, struct mi_timestamp
*start
)
2410 struct mi_timestamp now
;
2413 print_diff (file
, start
, &now
);
2417 mi_print_timing_maybe (struct ui_file
*file
)
2419 /* If the command is -enable-timing then do_timings may be true
2420 whilst current_command_ts is not initialized. */
2421 if (do_timings
&& current_command_ts
)
2422 print_diff_now (file
, current_command_ts
);
2426 print_diff (struct ui_file
*file
, struct mi_timestamp
*start
,
2427 struct mi_timestamp
*end
)
2429 using namespace std::chrono
;
2431 duration
<double> wallclock
= end
->wallclock
- start
->wallclock
;
2432 duration
<double> utime
= end
->utime
- start
->utime
;
2433 duration
<double> stime
= end
->stime
- start
->stime
;
2437 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
2438 wallclock
.count (), utime
.count (), stime
.count ());
2442 mi_cmd_trace_define_variable (const char *command
, char **argv
, int argc
)
2444 LONGEST initval
= 0;
2445 struct trace_state_variable
*tsv
;
2448 if (argc
!= 1 && argc
!= 2)
2449 error (_("Usage: -trace-define-variable VARIABLE [VALUE]"));
2453 error (_("Name of trace variable should start with '$'"));
2455 validate_trace_state_variable_name (name
);
2457 tsv
= find_trace_state_variable (name
);
2459 tsv
= create_trace_state_variable (name
);
2462 initval
= value_as_long (parse_and_eval (argv
[1]));
2464 tsv
->initial_value
= initval
;
2468 mi_cmd_trace_list_variables (const char *command
, char **argv
, int argc
)
2471 error (_("-trace-list-variables: no arguments allowed"));
2473 tvariables_info_1 ();
2477 mi_cmd_trace_find (const char *command
, char **argv
, int argc
)
2482 error (_("trace selection mode is required"));
2486 if (strcmp (mode
, "none") == 0)
2488 tfind_1 (tfind_number
, -1, 0, 0, 0);
2492 check_trace_running (current_trace_status ());
2494 if (strcmp (mode
, "frame-number") == 0)
2497 error (_("frame number is required"));
2498 tfind_1 (tfind_number
, atoi (argv
[1]), 0, 0, 0);
2500 else if (strcmp (mode
, "tracepoint-number") == 0)
2503 error (_("tracepoint number is required"));
2504 tfind_1 (tfind_tp
, atoi (argv
[1]), 0, 0, 0);
2506 else if (strcmp (mode
, "pc") == 0)
2509 error (_("PC is required"));
2510 tfind_1 (tfind_pc
, 0, parse_and_eval_address (argv
[1]), 0, 0);
2512 else if (strcmp (mode
, "pc-inside-range") == 0)
2515 error (_("Start and end PC are required"));
2516 tfind_1 (tfind_range
, 0, parse_and_eval_address (argv
[1]),
2517 parse_and_eval_address (argv
[2]), 0);
2519 else if (strcmp (mode
, "pc-outside-range") == 0)
2522 error (_("Start and end PC are required"));
2523 tfind_1 (tfind_outside
, 0, parse_and_eval_address (argv
[1]),
2524 parse_and_eval_address (argv
[2]), 0);
2526 else if (strcmp (mode
, "line") == 0)
2529 error (_("Line is required"));
2531 std::vector
<symtab_and_line
> sals
2532 = decode_line_with_current_source (argv
[1],
2533 DECODE_LINE_FUNFIRSTLINE
);
2534 const symtab_and_line
&sal
= sals
[0];
2536 if (sal
.symtab
== 0)
2537 error (_("Could not find the specified line"));
2539 CORE_ADDR start_pc
, end_pc
;
2540 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2541 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, 0);
2543 error (_("Could not find the specified line"));
2546 error (_("Invalid mode '%s'"), mode
);
2548 if (has_stack_frames () || get_traceframe_number () >= 0)
2549 print_stack_frame (get_selected_frame (NULL
), 1, LOC_AND_ADDRESS
, 1);
2553 mi_cmd_trace_save (const char *command
, char **argv
, int argc
)
2555 int target_saves
= 0;
2556 int generate_ctf
= 0;
2563 TARGET_SAVE_OPT
, CTF_OPT
2565 static const struct mi_opt opts
[] =
2567 {"r", TARGET_SAVE_OPT
, 0},
2568 {"ctf", CTF_OPT
, 0},
2574 int opt
= mi_getopt ("-trace-save", argc
, argv
, opts
,
2579 switch ((enum opt
) opt
)
2581 case TARGET_SAVE_OPT
:
2590 if (argc
- oind
!= 1)
2591 error (_("Exactly one argument required "
2592 "(file in which to save trace data)"));
2594 filename
= argv
[oind
];
2597 trace_save_ctf (filename
, target_saves
);
2599 trace_save_tfile (filename
, target_saves
);
2603 mi_cmd_trace_start (const char *command
, char **argv
, int argc
)
2605 start_tracing (NULL
);
2609 mi_cmd_trace_status (const char *command
, char **argv
, int argc
)
2611 trace_status_mi (0);
2615 mi_cmd_trace_stop (const char *command
, char **argv
, int argc
)
2617 stop_tracing (NULL
);
2618 trace_status_mi (1);
2621 /* Implement the "-ada-task-info" command. */
2624 mi_cmd_ada_task_info (const char *command
, char **argv
, int argc
)
2626 if (argc
!= 0 && argc
!= 1)
2627 error (_("Invalid MI command"));
2629 print_ada_task_info (current_uiout
, argv
[0], current_inferior ());
2632 /* Print EXPRESSION according to VALUES. */
2635 print_variable_or_computed (const char *expression
, enum print_values values
)
2639 struct ui_out
*uiout
= current_uiout
;
2643 expression_up expr
= parse_expression (expression
);
2645 if (values
== PRINT_SIMPLE_VALUES
)
2646 val
= evaluate_type (expr
.get ());
2648 val
= evaluate_expression (expr
.get ());
2650 gdb::optional
<ui_out_emit_tuple
> tuple_emitter
;
2651 if (values
!= PRINT_NO_VALUES
)
2652 tuple_emitter
.emplace (uiout
, nullptr);
2653 uiout
->field_string ("name", expression
);
2657 case PRINT_SIMPLE_VALUES
:
2658 type
= check_typedef (value_type (val
));
2659 type_print (value_type (val
), "", &stb
, -1);
2660 uiout
->field_stream ("type", stb
);
2661 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
2662 && TYPE_CODE (type
) != TYPE_CODE_STRUCT
2663 && TYPE_CODE (type
) != TYPE_CODE_UNION
)
2665 struct value_print_options opts
;
2667 get_no_prettyformat_print_options (&opts
);
2669 common_val_print (val
, &stb
, 0, &opts
, current_language
);
2670 uiout
->field_stream ("value", stb
);
2673 case PRINT_ALL_VALUES
:
2675 struct value_print_options opts
;
2677 get_no_prettyformat_print_options (&opts
);
2679 common_val_print (val
, &stb
, 0, &opts
, current_language
);
2680 uiout
->field_stream ("value", stb
);
2686 /* Implement the "-trace-frame-collected" command. */
2689 mi_cmd_trace_frame_collected (const char *command
, char **argv
, int argc
)
2691 struct bp_location
*tloc
;
2693 struct collection_list
*clist
;
2694 struct collection_list tracepoint_list
, stepping_list
;
2695 struct traceframe_info
*tinfo
;
2697 enum print_values var_print_values
= PRINT_ALL_VALUES
;
2698 enum print_values comp_print_values
= PRINT_ALL_VALUES
;
2699 int registers_format
= 'x';
2700 int memory_contents
= 0;
2701 struct ui_out
*uiout
= current_uiout
;
2709 static const struct mi_opt opts
[] =
2711 {"-var-print-values", VAR_PRINT_VALUES
, 1},
2712 {"-comp-print-values", COMP_PRINT_VALUES
, 1},
2713 {"-registers-format", REGISTERS_FORMAT
, 1},
2714 {"-memory-contents", MEMORY_CONTENTS
, 0},
2721 int opt
= mi_getopt ("-trace-frame-collected", argc
, argv
, opts
,
2725 switch ((enum opt
) opt
)
2727 case VAR_PRINT_VALUES
:
2728 var_print_values
= mi_parse_print_values (oarg
);
2730 case COMP_PRINT_VALUES
:
2731 comp_print_values
= mi_parse_print_values (oarg
);
2733 case REGISTERS_FORMAT
:
2734 registers_format
= oarg
[0];
2735 case MEMORY_CONTENTS
:
2736 memory_contents
= 1;
2742 error (_("Usage: -trace-frame-collected "
2743 "[--var-print-values PRINT_VALUES] "
2744 "[--comp-print-values PRINT_VALUES] "
2745 "[--registers-format FORMAT]"
2746 "[--memory-contents]"));
2748 /* This throws an error is not inspecting a trace frame. */
2749 tloc
= get_traceframe_location (&stepping_frame
);
2751 /* This command only makes sense for the current frame, not the
2753 scoped_restore_current_thread restore_thread
;
2754 select_frame (get_current_frame ());
2756 encode_actions (tloc
, &tracepoint_list
, &stepping_list
);
2759 clist
= &stepping_list
;
2761 clist
= &tracepoint_list
;
2763 tinfo
= get_traceframe_info ();
2765 /* Explicitly wholly collected variables. */
2769 ui_out_emit_list
list_emitter (uiout
, "explicit-variables");
2770 const std::vector
<std::string
> &wholly_collected
2771 = clist
->wholly_collected ();
2772 for (size_t i
= 0; i
< wholly_collected
.size (); i
++)
2774 const std::string
&str
= wholly_collected
[i
];
2775 print_variable_or_computed (str
.c_str (), var_print_values
);
2779 /* Computed expressions. */
2784 ui_out_emit_list
list_emitter (uiout
, "computed-expressions");
2786 const std::vector
<std::string
> &computed
= clist
->computed ();
2787 for (size_t i
= 0; i
< computed
.size (); i
++)
2789 const std::string
&str
= computed
[i
];
2790 print_variable_or_computed (str
.c_str (), comp_print_values
);
2794 /* Registers. Given pseudo-registers, and that some architectures
2795 (like MIPS) actually hide the raw registers, we don't go through
2796 the trace frame info, but instead consult the register cache for
2797 register availability. */
2799 struct frame_info
*frame
;
2800 struct gdbarch
*gdbarch
;
2804 ui_out_emit_list
list_emitter (uiout
, "registers");
2806 frame
= get_selected_frame (NULL
);
2807 gdbarch
= get_frame_arch (frame
);
2808 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
2810 for (regnum
= 0; regnum
< numregs
; regnum
++)
2812 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
2813 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
2816 output_register (frame
, regnum
, registers_format
, 1);
2820 /* Trace state variables. */
2822 struct cleanup
*list_cleanup
;
2827 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "tvars");
2830 make_cleanup (free_current_contents
, &tsvname
);
2832 for (i
= 0; VEC_iterate (int, tinfo
->tvars
, i
, tvar
); i
++)
2834 struct trace_state_variable
*tsv
;
2836 tsv
= find_trace_state_variable_by_number (tvar
);
2838 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
2842 tsvname
= (char *) xrealloc (tsvname
, strlen (tsv
->name
) + 2);
2844 strcpy (tsvname
+ 1, tsv
->name
);
2845 uiout
->field_string ("name", tsvname
);
2847 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
2849 uiout
->field_int ("current", tsv
->value
);
2853 uiout
->field_skip ("name");
2854 uiout
->field_skip ("current");
2858 do_cleanups (list_cleanup
);
2863 struct cleanup
*list_cleanup
;
2864 VEC(mem_range_s
) *available_memory
= NULL
;
2865 struct mem_range
*r
;
2868 traceframe_available_memory (&available_memory
, 0, ULONGEST_MAX
);
2869 make_cleanup (VEC_cleanup(mem_range_s
), &available_memory
);
2871 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "memory");
2873 for (i
= 0; VEC_iterate (mem_range_s
, available_memory
, i
, r
); i
++)
2875 struct cleanup
*cleanup_child
;
2877 struct gdbarch
*gdbarch
= target_gdbarch ();
2879 cleanup_child
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2881 uiout
->field_core_addr ("address", gdbarch
, r
->start
);
2882 uiout
->field_int ("length", r
->length
);
2884 data
= (gdb_byte
*) xmalloc (r
->length
);
2885 make_cleanup (xfree
, data
);
2887 if (memory_contents
)
2889 if (target_read_memory (r
->start
, data
, r
->length
) == 0)
2894 data_str
= (char *) xmalloc (r
->length
* 2 + 1);
2895 make_cleanup (xfree
, data_str
);
2897 for (m
= 0, p
= data_str
; m
< r
->length
; ++m
, p
+= 2)
2898 sprintf (p
, "%02x", data
[m
]);
2899 uiout
->field_string ("contents", data_str
);
2902 uiout
->field_skip ("contents");
2904 do_cleanups (cleanup_child
);
2907 do_cleanups (list_cleanup
);
2912 _initialize_mi_main (void)
2914 struct cmd_list_element
*c
;
2916 add_setshow_boolean_cmd ("mi-async", class_run
,
2918 Set whether MI asynchronous mode is enabled."), _("\
2919 Show whether MI asynchronous mode is enabled."), _("\
2920 Tells GDB whether MI should be in asynchronous mode."),
2921 set_mi_async_command
,
2922 show_mi_async_command
,
2926 /* Alias old "target-async" to "mi-async". */
2927 c
= add_alias_cmd ("target-async", "mi-async", class_run
, 0, &setlist
);
2928 deprecate_cmd (c
, "set mi-async");
2929 c
= add_alias_cmd ("target-async", "mi-async", class_run
, 0, &showlist
);
2930 deprecate_cmd (c
, "show mi-async");