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"
60 #include "run-time-clock.h"
62 #include "progspace-and-thread.h"
71 /* This is used to pass the current command timestamp down to
72 continuation routines. */
73 static struct mi_timestamp
*current_command_ts
;
75 static int do_timings
= 0;
78 /* Few commands would like to know if options like --thread-group were
79 explicitly specified. This variable keeps the current parsed
80 command including all option, and make it possible. */
81 static struct mi_parse
*current_context
;
83 int running_result_record_printed
= 1;
85 /* Flag indicating that the target has proceeded since the last
86 command was issued. */
89 extern void _initialize_mi_main (void);
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 gdb_byte prev_buffer
[MAX_REGISTER_SIZE
];
1115 gdb_byte this_buffer
[MAX_REGISTER_SIZE
];
1116 enum register_status prev_status
;
1117 enum register_status this_status
;
1119 /* First time through or after gdbarch change consider all registers
1121 if (!prev_regs
|| get_regcache_arch (prev_regs
) != gdbarch
)
1124 /* Get register contents and compare. */
1125 prev_status
= regcache_cooked_read (prev_regs
, regnum
, prev_buffer
);
1126 this_status
= regcache_cooked_read (this_regs
, regnum
, this_buffer
);
1128 if (this_status
!= prev_status
)
1130 else if (this_status
== REG_VALID
)
1131 return memcmp (prev_buffer
, this_buffer
,
1132 register_size (gdbarch
, regnum
)) != 0;
1137 /* Return a list of register number and value pairs. The valid
1138 arguments expected are: a letter indicating the format in which to
1139 display the registers contents. This can be one of: x
1140 (hexadecimal), d (decimal), N (natural), t (binary), o (octal), r
1141 (raw). After the format argument there can be a sequence of
1142 numbers, indicating which registers to fetch the content of. If
1143 the format is the only argument, a list of all the registers with
1144 their values is returned. */
1147 mi_cmd_data_list_register_values (const char *command
, char **argv
, int argc
)
1149 struct ui_out
*uiout
= current_uiout
;
1150 struct frame_info
*frame
;
1151 struct gdbarch
*gdbarch
;
1152 int regnum
, numregs
, format
;
1154 int skip_unavailable
= 0;
1160 static const struct mi_opt opts
[] =
1162 {"-skip-unavailable", SKIP_UNAVAILABLE
, 0},
1166 /* Note that the test for a valid register must include checking the
1167 gdbarch_register_name because gdbarch_num_regs may be allocated
1168 for the union of the register sets within a family of related
1169 processors. In this case, some entries of gdbarch_register_name
1170 will change depending upon the particular processor being
1176 int opt
= mi_getopt ("-data-list-register-values", argc
, argv
,
1177 opts
, &oind
, &oarg
);
1181 switch ((enum opt
) opt
)
1183 case SKIP_UNAVAILABLE
:
1184 skip_unavailable
= 1;
1189 if (argc
- oind
< 1)
1190 error (_("-data-list-register-values: Usage: "
1191 "-data-list-register-values [--skip-unavailable] <format>"
1192 " [<regnum1>...<regnumN>]"));
1194 format
= (int) argv
[oind
][0];
1196 frame
= get_selected_frame (NULL
);
1197 gdbarch
= get_frame_arch (frame
);
1198 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1200 ui_out_emit_list
list_emitter (uiout
, "register-values");
1202 if (argc
- oind
== 1)
1204 /* No args, beside the format: do all the regs. */
1209 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1210 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1213 output_register (frame
, regnum
, format
, skip_unavailable
);
1217 /* Else, list of register #s, just do listed regs. */
1218 for (i
= 1 + oind
; i
< argc
; i
++)
1220 regnum
= atoi (argv
[i
]);
1224 && gdbarch_register_name (gdbarch
, regnum
) != NULL
1225 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
1226 output_register (frame
, regnum
, format
, skip_unavailable
);
1228 error (_("bad register number"));
1232 /* Output one register REGNUM's contents in the desired FORMAT. If
1233 SKIP_UNAVAILABLE is true, skip the register if it is
1237 output_register (struct frame_info
*frame
, int regnum
, int format
,
1238 int skip_unavailable
)
1240 struct ui_out
*uiout
= current_uiout
;
1241 struct value
*val
= value_of_register (regnum
, frame
);
1242 struct value_print_options opts
;
1244 if (skip_unavailable
&& !value_entirely_available (val
))
1247 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1248 uiout
->field_int ("number", regnum
);
1258 get_formatted_print_options (&opts
, format
);
1260 val_print (value_type (val
),
1261 value_embedded_offset (val
), 0,
1262 &stb
, 0, val
, &opts
, current_language
);
1263 uiout
->field_stream ("value", stb
);
1266 /* Write given values into registers. The registers and values are
1267 given as pairs. The corresponding MI command is
1268 -data-write-register-values <format>
1269 [<regnum1> <value1>...<regnumN> <valueN>] */
1271 mi_cmd_data_write_register_values (const char *command
, char **argv
, int argc
)
1273 struct regcache
*regcache
;
1274 struct gdbarch
*gdbarch
;
1277 /* Note that the test for a valid register must include checking the
1278 gdbarch_register_name because gdbarch_num_regs may be allocated
1279 for the union of the register sets within a family of related
1280 processors. In this case, some entries of gdbarch_register_name
1281 will change depending upon the particular processor being
1284 regcache
= get_current_regcache ();
1285 gdbarch
= get_regcache_arch (regcache
);
1286 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1289 error (_("-data-write-register-values: Usage: -data-write-register-"
1290 "values <format> [<regnum1> <value1>...<regnumN> <valueN>]"));
1292 if (!target_has_registers
)
1293 error (_("-data-write-register-values: No registers."));
1296 error (_("-data-write-register-values: No regs and values specified."));
1299 error (_("-data-write-register-values: "
1300 "Regs and vals are not in pairs."));
1302 for (i
= 1; i
< argc
; i
= i
+ 2)
1304 int regnum
= atoi (argv
[i
]);
1306 if (regnum
>= 0 && regnum
< numregs
1307 && gdbarch_register_name (gdbarch
, regnum
)
1308 && *gdbarch_register_name (gdbarch
, regnum
))
1312 /* Get the value as a number. */
1313 value
= parse_and_eval_address (argv
[i
+ 1]);
1315 /* Write it down. */
1316 regcache_cooked_write_signed (regcache
, regnum
, value
);
1319 error (_("bad register number"));
1323 /* Evaluate the value of the argument. The argument is an
1324 expression. If the expression contains spaces it needs to be
1325 included in double quotes. */
1328 mi_cmd_data_evaluate_expression (const char *command
, char **argv
, int argc
)
1331 struct value_print_options opts
;
1332 struct ui_out
*uiout
= current_uiout
;
1335 error (_("-data-evaluate-expression: "
1336 "Usage: -data-evaluate-expression expression"));
1338 expression_up expr
= parse_expression (argv
[0]);
1340 val
= evaluate_expression (expr
.get ());
1344 /* Print the result of the expression evaluation. */
1345 get_user_print_options (&opts
);
1347 common_val_print (val
, &stb
, 0, &opts
, current_language
);
1349 uiout
->field_stream ("value", stb
);
1352 /* This is the -data-read-memory command.
1354 ADDR: start address of data to be dumped.
1355 WORD-FORMAT: a char indicating format for the ``word''. See
1357 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
1358 NR_ROW: Number of rows.
1359 NR_COL: The number of colums (words per row).
1360 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
1361 ASCHAR for unprintable characters.
1363 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
1364 displayes them. Returns:
1366 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
1369 The number of bytes read is SIZE*ROW*COL. */
1372 mi_cmd_data_read_memory (const char *command
, char **argv
, int argc
)
1374 struct gdbarch
*gdbarch
= get_current_arch ();
1375 struct ui_out
*uiout
= current_uiout
;
1377 long total_bytes
, nr_cols
, nr_rows
;
1379 struct type
*word_type
;
1391 static const struct mi_opt opts
[] =
1393 {"o", OFFSET_OPT
, 1},
1399 int opt
= mi_getopt ("-data-read-memory", argc
, argv
, opts
,
1404 switch ((enum opt
) opt
)
1407 offset
= atol (oarg
);
1414 if (argc
< 5 || argc
> 6)
1415 error (_("-data-read-memory: Usage: "
1416 "ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR]."));
1418 /* Extract all the arguments. */
1420 /* Start address of the memory dump. */
1421 addr
= parse_and_eval_address (argv
[0]) + offset
;
1422 /* The format character to use when displaying a memory word. See
1423 the ``x'' command. */
1424 word_format
= argv
[1][0];
1425 /* The size of the memory word. */
1426 word_size
= atol (argv
[2]);
1430 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1434 word_type
= builtin_type (gdbarch
)->builtin_int16
;
1438 word_type
= builtin_type (gdbarch
)->builtin_int32
;
1442 word_type
= builtin_type (gdbarch
)->builtin_int64
;
1446 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1449 /* The number of rows. */
1450 nr_rows
= atol (argv
[3]);
1452 error (_("-data-read-memory: invalid number of rows."));
1454 /* Number of bytes per row. */
1455 nr_cols
= atol (argv
[4]);
1457 error (_("-data-read-memory: invalid number of columns."));
1459 /* The un-printable character when printing ascii. */
1465 /* Create a buffer and read it in. */
1466 total_bytes
= word_size
* nr_rows
* nr_cols
;
1468 std::unique_ptr
<gdb_byte
[]> mbuf (new gdb_byte
[total_bytes
]);
1470 /* Dispatch memory reads to the topmost target, not the flattened
1472 nr_bytes
= target_read (current_target
.beneath
,
1473 TARGET_OBJECT_MEMORY
, NULL
, mbuf
.get (),
1476 error (_("Unable to read memory."));
1478 /* Output the header information. */
1479 uiout
->field_core_addr ("addr", gdbarch
, addr
);
1480 uiout
->field_int ("nr-bytes", nr_bytes
);
1481 uiout
->field_int ("total-bytes", total_bytes
);
1482 uiout
->field_core_addr ("next-row", gdbarch
, addr
+ word_size
* nr_cols
);
1483 uiout
->field_core_addr ("prev-row", gdbarch
, addr
- word_size
* nr_cols
);
1484 uiout
->field_core_addr ("next-page", gdbarch
, addr
+ total_bytes
);
1485 uiout
->field_core_addr ("prev-page", gdbarch
, addr
- total_bytes
);
1487 /* Build the result as a two dimentional table. */
1491 struct cleanup
*cleanup_list
;
1495 cleanup_list
= make_cleanup_ui_out_list_begin_end (uiout
, "memory");
1496 for (row
= 0, row_byte
= 0;
1498 row
++, row_byte
+= nr_cols
* word_size
)
1502 struct cleanup
*cleanup_list_data
;
1503 struct value_print_options opts
;
1505 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1506 uiout
->field_core_addr ("addr", gdbarch
, addr
+ row_byte
);
1507 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr +
1509 cleanup_list_data
= make_cleanup_ui_out_list_begin_end (uiout
, "data");
1510 get_formatted_print_options (&opts
, word_format
);
1511 for (col
= 0, col_byte
= row_byte
;
1513 col
++, col_byte
+= word_size
)
1515 if (col_byte
+ word_size
> nr_bytes
)
1517 uiout
->field_string (NULL
, "N/A");
1522 print_scalar_formatted (&mbuf
[col_byte
], word_type
, &opts
,
1523 word_asize
, &stream
);
1524 uiout
->field_stream (NULL
, stream
);
1527 do_cleanups (cleanup_list_data
);
1533 for (byte
= row_byte
;
1534 byte
< row_byte
+ word_size
* nr_cols
; byte
++)
1536 if (byte
>= nr_bytes
)
1538 else if (mbuf
[byte
] < 32 || mbuf
[byte
] > 126)
1539 stream
.putc (aschar
);
1541 stream
.putc (mbuf
[byte
]);
1543 uiout
->field_stream ("ascii", stream
);
1546 do_cleanups (cleanup_list
);
1551 mi_cmd_data_read_memory_bytes (const char *command
, char **argv
, int argc
)
1553 struct gdbarch
*gdbarch
= get_current_arch ();
1554 struct ui_out
*uiout
= current_uiout
;
1555 struct cleanup
*cleanups
;
1558 memory_read_result_s
*read_result
;
1560 VEC(memory_read_result_s
) *result
;
1562 int unit_size
= gdbarch_addressable_memory_unit_size (gdbarch
);
1569 static const struct mi_opt opts
[] =
1571 {"o", OFFSET_OPT
, 1},
1577 int opt
= mi_getopt ("-data-read-memory-bytes", argc
, argv
, opts
,
1581 switch ((enum opt
) opt
)
1584 offset
= atol (oarg
);
1592 error (_("Usage: [ -o OFFSET ] ADDR LENGTH."));
1594 addr
= parse_and_eval_address (argv
[0]) + offset
;
1595 length
= atol (argv
[1]);
1597 result
= read_memory_robust (current_target
.beneath
, addr
, length
);
1599 cleanups
= make_cleanup (free_memory_read_result_vector
, &result
);
1601 if (VEC_length (memory_read_result_s
, result
) == 0)
1602 error (_("Unable to read memory."));
1604 make_cleanup_ui_out_list_begin_end (uiout
, "memory");
1606 VEC_iterate (memory_read_result_s
, result
, ix
, read_result
);
1609 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1614 uiout
->field_core_addr ("begin", gdbarch
, read_result
->begin
);
1615 uiout
->field_core_addr ("offset", gdbarch
, read_result
->begin
- addr
);
1616 uiout
->field_core_addr ("end", gdbarch
, read_result
->end
);
1618 alloc_len
= (read_result
->end
- read_result
->begin
) * 2 * unit_size
+ 1;
1619 data
= (char *) xmalloc (alloc_len
);
1621 for (i
= 0, p
= data
;
1622 i
< ((read_result
->end
- read_result
->begin
) * unit_size
);
1625 sprintf (p
, "%02x", read_result
->data
[i
]);
1627 uiout
->field_string ("contents", data
);
1630 do_cleanups (cleanups
);
1633 /* Implementation of the -data-write_memory command.
1635 COLUMN_OFFSET: optional argument. Must be preceded by '-o'. The
1636 offset from the beginning of the memory grid row where the cell to
1638 ADDR: start address of the row in the memory grid where the memory
1639 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
1640 the location to write to.
1641 FORMAT: a char indicating format for the ``word''. See
1643 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
1644 VALUE: value to be written into the memory address.
1646 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1651 mi_cmd_data_write_memory (const char *command
, char **argv
, int argc
)
1653 struct gdbarch
*gdbarch
= get_current_arch ();
1654 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1657 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1658 enough when using a compiler other than GCC. */
1661 struct cleanup
*old_chain
;
1669 static const struct mi_opt opts
[] =
1671 {"o", OFFSET_OPT
, 1},
1677 int opt
= mi_getopt ("-data-write-memory", argc
, argv
, opts
,
1682 switch ((enum opt
) opt
)
1685 offset
= atol (oarg
);
1693 error (_("-data-write-memory: Usage: "
1694 "[-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE."));
1696 /* Extract all the arguments. */
1697 /* Start address of the memory dump. */
1698 addr
= parse_and_eval_address (argv
[0]);
1699 /* The size of the memory word. */
1700 word_size
= atol (argv
[2]);
1702 /* Calculate the real address of the write destination. */
1703 addr
+= (offset
* word_size
);
1705 /* Get the value as a number. */
1706 value
= parse_and_eval_address (argv
[3]);
1707 /* Get the value into an array. */
1708 buffer
= (gdb_byte
*) xmalloc (word_size
);
1709 old_chain
= make_cleanup (xfree
, buffer
);
1710 store_signed_integer (buffer
, word_size
, byte_order
, value
);
1711 /* Write it down to memory. */
1712 write_memory_with_notification (addr
, buffer
, word_size
);
1713 /* Free the buffer. */
1714 do_cleanups (old_chain
);
1717 /* Implementation of the -data-write-memory-bytes command.
1720 DATA: string of bytes to write at that address
1721 COUNT: number of bytes to be filled (decimal integer). */
1724 mi_cmd_data_write_memory_bytes (const char *command
, char **argv
, int argc
)
1730 size_t len_hex
, len_bytes
, len_units
, i
, steps
, remaining_units
;
1731 long int count_units
;
1732 struct cleanup
*back_to
;
1735 if (argc
!= 2 && argc
!= 3)
1736 error (_("Usage: ADDR DATA [COUNT]."));
1738 addr
= parse_and_eval_address (argv
[0]);
1740 len_hex
= strlen (cdata
);
1741 unit_size
= gdbarch_addressable_memory_unit_size (get_current_arch ());
1743 if (len_hex
% (unit_size
* 2) != 0)
1744 error (_("Hex-encoded '%s' must represent an integral number of "
1745 "addressable memory units."),
1748 len_bytes
= len_hex
/ 2;
1749 len_units
= len_bytes
/ unit_size
;
1752 count_units
= strtoul (argv
[2], NULL
, 10);
1754 count_units
= len_units
;
1756 databuf
= XNEWVEC (gdb_byte
, len_bytes
);
1757 back_to
= make_cleanup (xfree
, databuf
);
1759 for (i
= 0; i
< len_bytes
; ++i
)
1762 if (sscanf (cdata
+ i
* 2, "%02x", &x
) != 1)
1763 error (_("Invalid argument"));
1764 databuf
[i
] = (gdb_byte
) x
;
1767 if (len_units
< count_units
)
1769 /* Pattern is made of less units than count:
1770 repeat pattern to fill memory. */
1771 data
= (gdb_byte
*) xmalloc (count_units
* unit_size
);
1772 make_cleanup (xfree
, data
);
1774 /* Number of times the pattern is entirely repeated. */
1775 steps
= count_units
/ len_units
;
1776 /* Number of remaining addressable memory units. */
1777 remaining_units
= count_units
% len_units
;
1778 for (i
= 0; i
< steps
; i
++)
1779 memcpy (data
+ i
* len_bytes
, databuf
, len_bytes
);
1781 if (remaining_units
> 0)
1782 memcpy (data
+ steps
* len_bytes
, databuf
,
1783 remaining_units
* unit_size
);
1787 /* Pattern is longer than or equal to count:
1788 just copy count addressable memory units. */
1792 write_memory_with_notification (addr
, data
, count_units
);
1794 do_cleanups (back_to
);
1798 mi_cmd_enable_timings (const char *command
, char **argv
, int argc
)
1804 if (strcmp (argv
[0], "yes") == 0)
1806 else if (strcmp (argv
[0], "no") == 0)
1817 error (_("-enable-timings: Usage: %s {yes|no}"), command
);
1821 mi_cmd_list_features (const char *command
, char **argv
, int argc
)
1825 struct ui_out
*uiout
= current_uiout
;
1827 ui_out_emit_list
list_emitter (uiout
, "features");
1828 uiout
->field_string (NULL
, "frozen-varobjs");
1829 uiout
->field_string (NULL
, "pending-breakpoints");
1830 uiout
->field_string (NULL
, "thread-info");
1831 uiout
->field_string (NULL
, "data-read-memory-bytes");
1832 uiout
->field_string (NULL
, "breakpoint-notifications");
1833 uiout
->field_string (NULL
, "ada-task-info");
1834 uiout
->field_string (NULL
, "language-option");
1835 uiout
->field_string (NULL
, "info-gdb-mi-command");
1836 uiout
->field_string (NULL
, "undefined-command-error-code");
1837 uiout
->field_string (NULL
, "exec-run-start-option");
1839 if (ext_lang_initialized_p (get_ext_lang_defn (EXT_LANG_PYTHON
)))
1840 uiout
->field_string (NULL
, "python");
1845 error (_("-list-features should be passed no arguments"));
1849 mi_cmd_list_target_features (const char *command
, char **argv
, int argc
)
1853 struct ui_out
*uiout
= current_uiout
;
1855 ui_out_emit_list
list_emitter (uiout
, "features");
1857 uiout
->field_string (NULL
, "async");
1858 if (target_can_execute_reverse
)
1859 uiout
->field_string (NULL
, "reverse");
1863 error (_("-list-target-features should be passed no arguments"));
1867 mi_cmd_add_inferior (const char *command
, char **argv
, int argc
)
1869 struct inferior
*inf
;
1872 error (_("-add-inferior should be passed no arguments"));
1874 inf
= add_inferior_with_spaces ();
1876 current_uiout
->field_fmt ("inferior", "i%d", inf
->num
);
1879 /* Callback used to find the first inferior other than the current
1883 get_other_inferior (struct inferior
*inf
, void *arg
)
1885 if (inf
== current_inferior ())
1892 mi_cmd_remove_inferior (const char *command
, char **argv
, int argc
)
1895 struct inferior
*inf
;
1898 error (_("-remove-inferior should be passed a single argument"));
1900 if (sscanf (argv
[0], "i%d", &id
) != 1)
1901 error (_("the thread group id is syntactically invalid"));
1903 inf
= find_inferior_id (id
);
1905 error (_("the specified thread group does not exist"));
1908 error (_("cannot remove an active inferior"));
1910 if (inf
== current_inferior ())
1912 struct thread_info
*tp
= 0;
1913 struct inferior
*new_inferior
1914 = iterate_over_inferiors (get_other_inferior
, NULL
);
1916 if (new_inferior
== NULL
)
1917 error (_("Cannot remove last inferior"));
1919 set_current_inferior (new_inferior
);
1920 if (new_inferior
->pid
!= 0)
1921 tp
= any_thread_of_process (new_inferior
->pid
);
1922 switch_to_thread (tp
? tp
->ptid
: null_ptid
);
1923 set_current_program_space (new_inferior
->pspace
);
1926 delete_inferior (inf
);
1931 /* Execute a command within a safe environment.
1932 Return <0 for error; >=0 for ok.
1934 args->action will tell mi_execute_command what action
1935 to perfrom after the given command has executed (display/suppress
1936 prompt, display error). */
1939 captured_mi_execute_command (struct ui_out
*uiout
, struct mi_parse
*context
)
1941 struct mi_interp
*mi
= (struct mi_interp
*) command_interp ();
1942 struct cleanup
*cleanup
;
1945 current_command_ts
= context
->cmd_start
;
1947 current_token
= xstrdup (context
->token
);
1948 cleanup
= make_cleanup (free_current_contents
, ¤t_token
);
1950 running_result_record_printed
= 0;
1952 switch (context
->op
)
1955 /* A MI command was read from the input stream. */
1957 /* FIXME: gdb_???? */
1958 fprintf_unfiltered (mi
->raw_stdout
,
1959 " token=`%s' command=`%s' args=`%s'\n",
1960 context
->token
, context
->command
, context
->args
);
1962 mi_cmd_execute (context
);
1964 /* Print the result if there were no errors.
1966 Remember that on the way out of executing a command, you have
1967 to directly use the mi_interp's uiout, since the command
1968 could have reset the interpreter, in which case the current
1969 uiout will most likely crash in the mi_out_* routines. */
1970 if (!running_result_record_printed
)
1972 fputs_unfiltered (context
->token
, mi
->raw_stdout
);
1973 /* There's no particularly good reason why target-connect results
1974 in not ^done. Should kill ^connected for MI3. */
1975 fputs_unfiltered (strcmp (context
->command
, "target-select") == 0
1976 ? "^connected" : "^done", mi
->raw_stdout
);
1977 mi_out_put (uiout
, mi
->raw_stdout
);
1978 mi_out_rewind (uiout
);
1979 mi_print_timing_maybe (mi
->raw_stdout
);
1980 fputs_unfiltered ("\n", mi
->raw_stdout
);
1983 /* The command does not want anything to be printed. In that
1984 case, the command probably should not have written anything
1985 to uiout, but in case it has written something, discard it. */
1986 mi_out_rewind (uiout
);
1993 /* A CLI command was read from the input stream. */
1994 /* This "feature" will be removed as soon as we have a
1995 complete set of mi commands. */
1996 /* Echo the command on the console. */
1997 fprintf_unfiltered (gdb_stdlog
, "%s\n", context
->command
);
1998 /* Call the "console" interpreter. */
1999 argv
[0] = (char *) INTERP_CONSOLE
;
2000 argv
[1] = context
->command
;
2001 mi_cmd_interpreter_exec ("-interpreter-exec", argv
, 2);
2003 /* If we changed interpreters, DON'T print out anything. */
2004 if (current_interp_named_p (INTERP_MI
)
2005 || current_interp_named_p (INTERP_MI1
)
2006 || current_interp_named_p (INTERP_MI2
)
2007 || current_interp_named_p (INTERP_MI3
))
2009 if (!running_result_record_printed
)
2011 fputs_unfiltered (context
->token
, mi
->raw_stdout
);
2012 fputs_unfiltered ("^done", mi
->raw_stdout
);
2013 mi_out_put (uiout
, mi
->raw_stdout
);
2014 mi_out_rewind (uiout
);
2015 mi_print_timing_maybe (mi
->raw_stdout
);
2016 fputs_unfiltered ("\n", mi
->raw_stdout
);
2019 mi_out_rewind (uiout
);
2025 do_cleanups (cleanup
);
2028 /* Print a gdb exception to the MI output stream. */
2031 mi_print_exception (const char *token
, struct gdb_exception exception
)
2033 struct mi_interp
*mi
= (struct mi_interp
*) current_interpreter ();
2035 fputs_unfiltered (token
, mi
->raw_stdout
);
2036 fputs_unfiltered ("^error,msg=\"", mi
->raw_stdout
);
2037 if (exception
.message
== NULL
)
2038 fputs_unfiltered ("unknown error", mi
->raw_stdout
);
2040 fputstr_unfiltered (exception
.message
, '"', mi
->raw_stdout
);
2041 fputs_unfiltered ("\"", mi
->raw_stdout
);
2043 switch (exception
.error
)
2045 case UNDEFINED_COMMAND_ERROR
:
2046 fputs_unfiltered (",code=\"undefined-command\"", mi
->raw_stdout
);
2050 fputs_unfiltered ("\n", mi
->raw_stdout
);
2053 /* Determine whether the parsed command already notifies the
2054 user_selected_context_changed observer. */
2057 command_notifies_uscc_observer (struct mi_parse
*command
)
2059 if (command
->op
== CLI_COMMAND
)
2061 /* CLI commands "thread" and "inferior" already send it. */
2062 return (strncmp (command
->command
, "thread ", 7) == 0
2063 || strncmp (command
->command
, "inferior ", 9) == 0);
2065 else /* MI_COMMAND */
2067 if (strcmp (command
->command
, "interpreter-exec") == 0
2068 && command
->argc
> 1)
2070 /* "thread" and "inferior" again, but through -interpreter-exec. */
2071 return (strncmp (command
->argv
[1], "thread ", 7) == 0
2072 || strncmp (command
->argv
[1], "inferior ", 9) == 0);
2076 /* -thread-select already sends it. */
2077 return strcmp (command
->command
, "thread-select") == 0;
2082 mi_execute_command (const char *cmd
, int from_tty
)
2085 std::unique_ptr
<struct mi_parse
> command
;
2087 /* This is to handle EOF (^D). We just quit gdb. */
2088 /* FIXME: we should call some API function here. */
2090 quit_force (NULL
, from_tty
);
2092 target_log_command (cmd
);
2096 command
= mi_parse (cmd
, &token
);
2098 CATCH (exception
, RETURN_MASK_ALL
)
2100 mi_print_exception (token
, exception
);
2105 if (command
!= NULL
)
2107 ptid_t previous_ptid
= inferior_ptid
;
2109 gdb::optional
<scoped_restore_tmpl
<int>> restore_suppress
;
2111 if (command
->cmd
!= NULL
&& command
->cmd
->suppress_notification
!= NULL
)
2112 restore_suppress
.emplace (command
->cmd
->suppress_notification
, 1);
2114 command
->token
= token
;
2118 command
->cmd_start
= new mi_timestamp ();
2119 timestamp (command
->cmd_start
);
2124 captured_mi_execute_command (current_uiout
, command
.get ());
2126 CATCH (result
, RETURN_MASK_ALL
)
2128 /* Like in start_event_loop, enable input and force display
2129 of the prompt. Otherwise, any command that calls
2130 async_disable_stdin, and then throws, will leave input
2132 async_enable_stdin ();
2133 current_ui
->prompt_state
= PROMPT_NEEDED
;
2135 /* The command execution failed and error() was called
2137 mi_print_exception (command
->token
, result
);
2138 mi_out_rewind (current_uiout
);
2142 bpstat_do_actions ();
2144 if (/* The notifications are only output when the top-level
2145 interpreter (specified on the command line) is MI. */
2146 interp_ui_out (top_level_interpreter ())->is_mi_like_p ()
2147 /* Don't try report anything if there are no threads --
2148 the program is dead. */
2149 && thread_count () != 0
2150 /* If the command already reports the thread change, no need to do it
2152 && !command_notifies_uscc_observer (command
.get ()))
2154 struct mi_interp
*mi
= (struct mi_interp
*) top_level_interpreter ();
2155 int report_change
= 0;
2157 if (command
->thread
== -1)
2159 report_change
= (!ptid_equal (previous_ptid
, null_ptid
)
2160 && !ptid_equal (inferior_ptid
, previous_ptid
)
2161 && !ptid_equal (inferior_ptid
, null_ptid
));
2163 else if (!ptid_equal (inferior_ptid
, null_ptid
))
2165 struct thread_info
*ti
= inferior_thread ();
2167 report_change
= (ti
->global_num
!= command
->thread
);
2172 observer_notify_user_selected_context_changed
2173 (USER_SELECTED_THREAD
| USER_SELECTED_FRAME
);
2180 mi_cmd_execute (struct mi_parse
*parse
)
2182 struct cleanup
*cleanup
;
2184 cleanup
= prepare_execute_command ();
2186 if (parse
->all
&& parse
->thread_group
!= -1)
2187 error (_("Cannot specify --thread-group together with --all"));
2189 if (parse
->all
&& parse
->thread
!= -1)
2190 error (_("Cannot specify --thread together with --all"));
2192 if (parse
->thread_group
!= -1 && parse
->thread
!= -1)
2193 error (_("Cannot specify --thread together with --thread-group"));
2195 if (parse
->frame
!= -1 && parse
->thread
== -1)
2196 error (_("Cannot specify --frame without --thread"));
2198 if (parse
->thread_group
!= -1)
2200 struct inferior
*inf
= find_inferior_id (parse
->thread_group
);
2201 struct thread_info
*tp
= 0;
2204 error (_("Invalid thread group for the --thread-group option"));
2206 set_current_inferior (inf
);
2207 /* This behaviour means that if --thread-group option identifies
2208 an inferior with multiple threads, then a random one will be
2209 picked. This is not a problem -- frontend should always
2210 provide --thread if it wishes to operate on a specific
2213 tp
= any_live_thread_of_process (inf
->pid
);
2214 switch_to_thread (tp
? tp
->ptid
: null_ptid
);
2215 set_current_program_space (inf
->pspace
);
2218 if (parse
->thread
!= -1)
2220 struct thread_info
*tp
= find_thread_global_id (parse
->thread
);
2223 error (_("Invalid thread id: %d"), parse
->thread
);
2225 if (is_exited (tp
->ptid
))
2226 error (_("Thread id: %d has terminated"), parse
->thread
);
2228 switch_to_thread (tp
->ptid
);
2231 if (parse
->frame
!= -1)
2233 struct frame_info
*fid
;
2234 int frame
= parse
->frame
;
2236 fid
= find_relative_frame (get_current_frame (), &frame
);
2238 /* find_relative_frame was successful */
2241 error (_("Invalid frame id: %d"), frame
);
2244 if (parse
->language
!= language_unknown
)
2246 make_cleanup_restore_current_language ();
2247 set_language (parse
->language
);
2250 current_context
= parse
;
2252 if (parse
->cmd
->argv_func
!= NULL
)
2254 parse
->cmd
->argv_func (parse
->command
, parse
->argv
, parse
->argc
);
2256 else if (parse
->cmd
->cli
.cmd
!= 0)
2258 /* FIXME: DELETE THIS. */
2259 /* The operation is still implemented by a cli command. */
2260 /* Must be a synchronous one. */
2261 mi_execute_cli_command (parse
->cmd
->cli
.cmd
, parse
->cmd
->cli
.args_p
,
2266 /* FIXME: DELETE THIS. */
2269 stb
.puts ("Undefined mi command: ");
2270 stb
.putstr (parse
->command
, '"');
2271 stb
.puts (" (missing implementation)");
2275 do_cleanups (cleanup
);
2278 /* FIXME: This is just a hack so we can get some extra commands going.
2279 We don't want to channel things through the CLI, but call libgdb directly.
2280 Use only for synchronous commands. */
2283 mi_execute_cli_command (const char *cmd
, int args_p
, const char *args
)
2287 struct cleanup
*old_cleanups
;
2291 run
= xstrprintf ("%s %s", cmd
, args
);
2293 run
= xstrdup (cmd
);
2295 /* FIXME: gdb_???? */
2296 fprintf_unfiltered (gdb_stdout
, "cli=%s run=%s\n",
2298 old_cleanups
= make_cleanup (xfree
, run
);
2299 execute_command (run
, 0 /* from_tty */ );
2300 do_cleanups (old_cleanups
);
2306 mi_execute_async_cli_command (const char *cli_command
, char **argv
, int argc
)
2308 struct cleanup
*old_cleanups
;
2312 run
= xstrprintf ("%s %s&", cli_command
, argc
? *argv
: "");
2314 run
= xstrprintf ("%s %s", cli_command
, argc
? *argv
: "");
2315 old_cleanups
= make_cleanup (xfree
, run
);
2317 execute_command (run
, 0 /* from_tty */ );
2319 /* Do this before doing any printing. It would appear that some
2320 print code leaves garbage around in the buffer. */
2321 do_cleanups (old_cleanups
);
2325 mi_load_progress (const char *section_name
,
2326 unsigned long sent_so_far
,
2327 unsigned long total_section
,
2328 unsigned long total_sent
,
2329 unsigned long grand_total
)
2331 using namespace std::chrono
;
2332 static steady_clock::time_point last_update
;
2333 static char *previous_sect_name
= NULL
;
2335 struct ui_out
*saved_uiout
;
2336 struct ui_out
*uiout
;
2337 struct mi_interp
*mi
= (struct mi_interp
*) current_interpreter ();
2339 /* This function is called through deprecated_show_load_progress
2340 which means uiout may not be correct. Fix it for the duration
2341 of this function. */
2342 saved_uiout
= current_uiout
;
2344 if (current_interp_named_p (INTERP_MI
)
2345 || current_interp_named_p (INTERP_MI2
))
2346 current_uiout
= mi_out_new (2);
2347 else if (current_interp_named_p (INTERP_MI1
))
2348 current_uiout
= mi_out_new (1);
2349 else if (current_interp_named_p (INTERP_MI3
))
2350 current_uiout
= mi_out_new (3);
2354 uiout
= current_uiout
;
2356 new_section
= (previous_sect_name
?
2357 strcmp (previous_sect_name
, section_name
) : 1);
2360 xfree (previous_sect_name
);
2361 previous_sect_name
= xstrdup (section_name
);
2364 fputs_unfiltered (current_token
, mi
->raw_stdout
);
2365 fputs_unfiltered ("+download", mi
->raw_stdout
);
2367 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
2368 uiout
->field_string ("section", section_name
);
2369 uiout
->field_int ("section-size", total_section
);
2370 uiout
->field_int ("total-size", grand_total
);
2372 mi_out_put (uiout
, mi
->raw_stdout
);
2373 fputs_unfiltered ("\n", mi
->raw_stdout
);
2374 gdb_flush (mi
->raw_stdout
);
2377 steady_clock::time_point time_now
= steady_clock::now ();
2378 if (time_now
- last_update
> milliseconds (500))
2380 last_update
= time_now
;
2382 fputs_unfiltered (current_token
, mi
->raw_stdout
);
2383 fputs_unfiltered ("+download", mi
->raw_stdout
);
2385 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
2386 uiout
->field_string ("section", section_name
);
2387 uiout
->field_int ("section-sent", sent_so_far
);
2388 uiout
->field_int ("section-size", total_section
);
2389 uiout
->field_int ("total-sent", total_sent
);
2390 uiout
->field_int ("total-size", grand_total
);
2392 mi_out_put (uiout
, mi
->raw_stdout
);
2393 fputs_unfiltered ("\n", mi
->raw_stdout
);
2394 gdb_flush (mi
->raw_stdout
);
2398 current_uiout
= saved_uiout
;
2402 timestamp (struct mi_timestamp
*tv
)
2404 using namespace std::chrono
;
2406 tv
->wallclock
= steady_clock::now ();
2407 run_time_clock::now (tv
->utime
, tv
->stime
);
2411 print_diff_now (struct ui_file
*file
, struct mi_timestamp
*start
)
2413 struct mi_timestamp now
;
2416 print_diff (file
, start
, &now
);
2420 mi_print_timing_maybe (struct ui_file
*file
)
2422 /* If the command is -enable-timing then do_timings may be true
2423 whilst current_command_ts is not initialized. */
2424 if (do_timings
&& current_command_ts
)
2425 print_diff_now (file
, current_command_ts
);
2429 print_diff (struct ui_file
*file
, struct mi_timestamp
*start
,
2430 struct mi_timestamp
*end
)
2432 using namespace std::chrono
;
2434 duration
<double> wallclock
= end
->wallclock
- start
->wallclock
;
2435 duration
<double> utime
= end
->utime
- start
->utime
;
2436 duration
<double> stime
= end
->stime
- start
->stime
;
2440 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
2441 wallclock
.count (), utime
.count (), stime
.count ());
2445 mi_cmd_trace_define_variable (const char *command
, char **argv
, int argc
)
2447 LONGEST initval
= 0;
2448 struct trace_state_variable
*tsv
;
2451 if (argc
!= 1 && argc
!= 2)
2452 error (_("Usage: -trace-define-variable VARIABLE [VALUE]"));
2456 error (_("Name of trace variable should start with '$'"));
2458 validate_trace_state_variable_name (name
);
2460 tsv
= find_trace_state_variable (name
);
2462 tsv
= create_trace_state_variable (name
);
2465 initval
= value_as_long (parse_and_eval (argv
[1]));
2467 tsv
->initial_value
= initval
;
2471 mi_cmd_trace_list_variables (const char *command
, char **argv
, int argc
)
2474 error (_("-trace-list-variables: no arguments allowed"));
2476 tvariables_info_1 ();
2480 mi_cmd_trace_find (const char *command
, char **argv
, int argc
)
2485 error (_("trace selection mode is required"));
2489 if (strcmp (mode
, "none") == 0)
2491 tfind_1 (tfind_number
, -1, 0, 0, 0);
2495 check_trace_running (current_trace_status ());
2497 if (strcmp (mode
, "frame-number") == 0)
2500 error (_("frame number is required"));
2501 tfind_1 (tfind_number
, atoi (argv
[1]), 0, 0, 0);
2503 else if (strcmp (mode
, "tracepoint-number") == 0)
2506 error (_("tracepoint number is required"));
2507 tfind_1 (tfind_tp
, atoi (argv
[1]), 0, 0, 0);
2509 else if (strcmp (mode
, "pc") == 0)
2512 error (_("PC is required"));
2513 tfind_1 (tfind_pc
, 0, parse_and_eval_address (argv
[1]), 0, 0);
2515 else if (strcmp (mode
, "pc-inside-range") == 0)
2518 error (_("Start and end PC are required"));
2519 tfind_1 (tfind_range
, 0, parse_and_eval_address (argv
[1]),
2520 parse_and_eval_address (argv
[2]), 0);
2522 else if (strcmp (mode
, "pc-outside-range") == 0)
2525 error (_("Start and end PC are required"));
2526 tfind_1 (tfind_outside
, 0, parse_and_eval_address (argv
[1]),
2527 parse_and_eval_address (argv
[2]), 0);
2529 else if (strcmp (mode
, "line") == 0)
2531 struct symtabs_and_lines sals
;
2532 struct symtab_and_line sal
;
2533 static CORE_ADDR start_pc
, end_pc
;
2534 struct cleanup
*back_to
;
2537 error (_("Line is required"));
2539 sals
= decode_line_with_current_source (argv
[1],
2540 DECODE_LINE_FUNFIRSTLINE
);
2541 back_to
= make_cleanup (xfree
, sals
.sals
);
2545 if (sal
.symtab
== 0)
2546 error (_("Could not find the specified line"));
2548 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2549 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, 0);
2551 error (_("Could not find the specified line"));
2553 do_cleanups (back_to
);
2556 error (_("Invalid mode '%s'"), mode
);
2558 if (has_stack_frames () || get_traceframe_number () >= 0)
2559 print_stack_frame (get_selected_frame (NULL
), 1, LOC_AND_ADDRESS
, 1);
2563 mi_cmd_trace_save (const char *command
, char **argv
, int argc
)
2565 int target_saves
= 0;
2566 int generate_ctf
= 0;
2573 TARGET_SAVE_OPT
, CTF_OPT
2575 static const struct mi_opt opts
[] =
2577 {"r", TARGET_SAVE_OPT
, 0},
2578 {"ctf", CTF_OPT
, 0},
2584 int opt
= mi_getopt ("-trace-save", argc
, argv
, opts
,
2589 switch ((enum opt
) opt
)
2591 case TARGET_SAVE_OPT
:
2600 if (argc
- oind
!= 1)
2601 error (_("Exactly one argument required "
2602 "(file in which to save trace data)"));
2604 filename
= argv
[oind
];
2607 trace_save_ctf (filename
, target_saves
);
2609 trace_save_tfile (filename
, target_saves
);
2613 mi_cmd_trace_start (const char *command
, char **argv
, int argc
)
2615 start_tracing (NULL
);
2619 mi_cmd_trace_status (const char *command
, char **argv
, int argc
)
2621 trace_status_mi (0);
2625 mi_cmd_trace_stop (const char *command
, char **argv
, int argc
)
2627 stop_tracing (NULL
);
2628 trace_status_mi (1);
2631 /* Implement the "-ada-task-info" command. */
2634 mi_cmd_ada_task_info (const char *command
, char **argv
, int argc
)
2636 if (argc
!= 0 && argc
!= 1)
2637 error (_("Invalid MI command"));
2639 print_ada_task_info (current_uiout
, argv
[0], current_inferior ());
2642 /* Print EXPRESSION according to VALUES. */
2645 print_variable_or_computed (const char *expression
, enum print_values values
)
2649 struct ui_out
*uiout
= current_uiout
;
2653 expression_up expr
= parse_expression (expression
);
2655 if (values
== PRINT_SIMPLE_VALUES
)
2656 val
= evaluate_type (expr
.get ());
2658 val
= evaluate_expression (expr
.get ());
2660 gdb::optional
<ui_out_emit_tuple
> tuple_emitter
;
2661 if (values
!= PRINT_NO_VALUES
)
2662 tuple_emitter
.emplace (uiout
, nullptr);
2663 uiout
->field_string ("name", expression
);
2667 case PRINT_SIMPLE_VALUES
:
2668 type
= check_typedef (value_type (val
));
2669 type_print (value_type (val
), "", &stb
, -1);
2670 uiout
->field_stream ("type", stb
);
2671 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
2672 && TYPE_CODE (type
) != TYPE_CODE_STRUCT
2673 && TYPE_CODE (type
) != TYPE_CODE_UNION
)
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
);
2683 case PRINT_ALL_VALUES
:
2685 struct value_print_options opts
;
2687 get_no_prettyformat_print_options (&opts
);
2689 common_val_print (val
, &stb
, 0, &opts
, current_language
);
2690 uiout
->field_stream ("value", stb
);
2696 /* Implement the "-trace-frame-collected" command. */
2699 mi_cmd_trace_frame_collected (const char *command
, char **argv
, int argc
)
2701 struct bp_location
*tloc
;
2703 struct collection_list
*clist
;
2704 struct collection_list tracepoint_list
, stepping_list
;
2705 struct traceframe_info
*tinfo
;
2707 enum print_values var_print_values
= PRINT_ALL_VALUES
;
2708 enum print_values comp_print_values
= PRINT_ALL_VALUES
;
2709 int registers_format
= 'x';
2710 int memory_contents
= 0;
2711 struct ui_out
*uiout
= current_uiout
;
2719 static const struct mi_opt opts
[] =
2721 {"-var-print-values", VAR_PRINT_VALUES
, 1},
2722 {"-comp-print-values", COMP_PRINT_VALUES
, 1},
2723 {"-registers-format", REGISTERS_FORMAT
, 1},
2724 {"-memory-contents", MEMORY_CONTENTS
, 0},
2731 int opt
= mi_getopt ("-trace-frame-collected", argc
, argv
, opts
,
2735 switch ((enum opt
) opt
)
2737 case VAR_PRINT_VALUES
:
2738 var_print_values
= mi_parse_print_values (oarg
);
2740 case COMP_PRINT_VALUES
:
2741 comp_print_values
= mi_parse_print_values (oarg
);
2743 case REGISTERS_FORMAT
:
2744 registers_format
= oarg
[0];
2745 case MEMORY_CONTENTS
:
2746 memory_contents
= 1;
2752 error (_("Usage: -trace-frame-collected "
2753 "[--var-print-values PRINT_VALUES] "
2754 "[--comp-print-values PRINT_VALUES] "
2755 "[--registers-format FORMAT]"
2756 "[--memory-contents]"));
2758 /* This throws an error is not inspecting a trace frame. */
2759 tloc
= get_traceframe_location (&stepping_frame
);
2761 /* This command only makes sense for the current frame, not the
2763 scoped_restore_current_thread restore_thread
;
2764 select_frame (get_current_frame ());
2766 encode_actions (tloc
, &tracepoint_list
, &stepping_list
);
2769 clist
= &stepping_list
;
2771 clist
= &tracepoint_list
;
2773 tinfo
= get_traceframe_info ();
2775 /* Explicitly wholly collected variables. */
2779 ui_out_emit_list
list_emitter (uiout
, "explicit-variables");
2780 const std::vector
<std::string
> &wholly_collected
2781 = clist
->wholly_collected ();
2782 for (size_t i
= 0; i
< wholly_collected
.size (); i
++)
2784 const std::string
&str
= wholly_collected
[i
];
2785 print_variable_or_computed (str
.c_str (), var_print_values
);
2789 /* Computed expressions. */
2794 ui_out_emit_list
list_emitter (uiout
, "computed-expressions");
2796 const std::vector
<std::string
> &computed
= clist
->computed ();
2797 for (size_t i
= 0; i
< computed
.size (); i
++)
2799 const std::string
&str
= computed
[i
];
2800 print_variable_or_computed (str
.c_str (), comp_print_values
);
2804 /* Registers. Given pseudo-registers, and that some architectures
2805 (like MIPS) actually hide the raw registers, we don't go through
2806 the trace frame info, but instead consult the register cache for
2807 register availability. */
2809 struct frame_info
*frame
;
2810 struct gdbarch
*gdbarch
;
2814 ui_out_emit_list
list_emitter (uiout
, "registers");
2816 frame
= get_selected_frame (NULL
);
2817 gdbarch
= get_frame_arch (frame
);
2818 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
2820 for (regnum
= 0; regnum
< numregs
; regnum
++)
2822 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
2823 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
2826 output_register (frame
, regnum
, registers_format
, 1);
2830 /* Trace state variables. */
2832 struct cleanup
*list_cleanup
;
2837 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "tvars");
2840 make_cleanup (free_current_contents
, &tsvname
);
2842 for (i
= 0; VEC_iterate (int, tinfo
->tvars
, i
, tvar
); i
++)
2844 struct trace_state_variable
*tsv
;
2846 tsv
= find_trace_state_variable_by_number (tvar
);
2848 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
2852 tsvname
= (char *) xrealloc (tsvname
, strlen (tsv
->name
) + 2);
2854 strcpy (tsvname
+ 1, tsv
->name
);
2855 uiout
->field_string ("name", tsvname
);
2857 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
2859 uiout
->field_int ("current", tsv
->value
);
2863 uiout
->field_skip ("name");
2864 uiout
->field_skip ("current");
2868 do_cleanups (list_cleanup
);
2873 struct cleanup
*list_cleanup
;
2874 VEC(mem_range_s
) *available_memory
= NULL
;
2875 struct mem_range
*r
;
2878 traceframe_available_memory (&available_memory
, 0, ULONGEST_MAX
);
2879 make_cleanup (VEC_cleanup(mem_range_s
), &available_memory
);
2881 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "memory");
2883 for (i
= 0; VEC_iterate (mem_range_s
, available_memory
, i
, r
); i
++)
2885 struct cleanup
*cleanup_child
;
2887 struct gdbarch
*gdbarch
= target_gdbarch ();
2889 cleanup_child
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2891 uiout
->field_core_addr ("address", gdbarch
, r
->start
);
2892 uiout
->field_int ("length", r
->length
);
2894 data
= (gdb_byte
*) xmalloc (r
->length
);
2895 make_cleanup (xfree
, data
);
2897 if (memory_contents
)
2899 if (target_read_memory (r
->start
, data
, r
->length
) == 0)
2904 data_str
= (char *) xmalloc (r
->length
* 2 + 1);
2905 make_cleanup (xfree
, data_str
);
2907 for (m
= 0, p
= data_str
; m
< r
->length
; ++m
, p
+= 2)
2908 sprintf (p
, "%02x", data
[m
]);
2909 uiout
->field_string ("contents", data_str
);
2912 uiout
->field_skip ("contents");
2914 do_cleanups (cleanup_child
);
2917 do_cleanups (list_cleanup
);
2922 _initialize_mi_main (void)
2924 struct cmd_list_element
*c
;
2926 add_setshow_boolean_cmd ("mi-async", class_run
,
2928 Set whether MI asynchronous mode is enabled."), _("\
2929 Show whether MI asynchronous mode is enabled."), _("\
2930 Tells GDB whether MI should be in asynchronous mode."),
2931 set_mi_async_command
,
2932 show_mi_async_command
,
2936 /* Alias old "target-async" to "mi-async". */
2937 c
= add_alias_cmd ("target-async", "mi-async", class_run
, 0, &setlist
);
2938 deprecate_cmd (c
, "set mi-async");
2939 c
= add_alias_cmd ("target-async", "mi-async", class_run
, 0, &showlist
);
2940 deprecate_cmd (c
, "show mi-async");