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"
70 /* This is used to pass the current command timestamp down to
71 continuation routines. */
72 static struct mi_timestamp
*current_command_ts
;
74 static int do_timings
= 0;
77 /* Few commands would like to know if options like --thread-group were
78 explicitly specified. This variable keeps the current parsed
79 command including all option, and make it possible. */
80 static struct mi_parse
*current_context
;
82 int running_result_record_printed
= 1;
84 /* Flag indicating that the target has proceeded since the last
85 command was issued. */
88 extern void _initialize_mi_main (void);
89 static void mi_cmd_execute (struct mi_parse
*parse
);
91 static void mi_execute_cli_command (const char *cmd
, int args_p
,
93 static void mi_execute_async_cli_command (const char *cli_command
,
94 char **argv
, int argc
);
95 static int register_changed_p (int regnum
, struct regcache
*,
97 static void output_register (struct frame_info
*, int regnum
, int format
,
98 int skip_unavailable
);
100 /* Controls whether the frontend wants MI in async mode. */
101 static int mi_async
= 0;
103 /* The set command writes to this variable. If the inferior is
104 executing, mi_async is *not* updated. */
105 static int mi_async_1
= 0;
108 set_mi_async_command (char *args
, int from_tty
,
109 struct cmd_list_element
*c
)
111 if (have_live_inferiors ())
113 mi_async_1
= mi_async
;
114 error (_("Cannot change this setting while the inferior is running."));
117 mi_async
= mi_async_1
;
121 show_mi_async_command (struct ui_file
*file
, int from_tty
,
122 struct cmd_list_element
*c
,
125 fprintf_filtered (file
,
126 _("Whether MI is in asynchronous mode is %s.\n"),
130 /* A wrapper for target_can_async_p that takes the MI setting into
136 return mi_async
&& target_can_async_p ();
139 /* Command implementations. FIXME: Is this libgdb? No. This is the MI
140 layer that calls libgdb. Any operation used in the below should be
143 static void timestamp (struct mi_timestamp
*tv
);
145 static void print_diff (struct ui_file
*file
, struct mi_timestamp
*start
,
146 struct mi_timestamp
*end
);
149 mi_cmd_gdb_exit (const char *command
, char **argv
, int argc
)
151 struct mi_interp
*mi
= (struct mi_interp
*) current_interpreter ();
153 /* We have to print everything right here because we never return. */
155 fputs_unfiltered (current_token
, mi
->raw_stdout
);
156 fputs_unfiltered ("^exit\n", mi
->raw_stdout
);
157 mi_out_put (current_uiout
, mi
->raw_stdout
);
158 gdb_flush (mi
->raw_stdout
);
159 /* FIXME: The function called is not yet a formal libgdb function. */
160 quit_force (NULL
, FROM_TTY
);
164 mi_cmd_exec_next (const char *command
, char **argv
, int argc
)
166 /* FIXME: Should call a libgdb function, not a cli wrapper. */
167 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
168 mi_execute_async_cli_command ("reverse-next", argv
+ 1, argc
- 1);
170 mi_execute_async_cli_command ("next", argv
, argc
);
174 mi_cmd_exec_next_instruction (const char *command
, char **argv
, int argc
)
176 /* FIXME: Should call a libgdb function, not a cli wrapper. */
177 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
178 mi_execute_async_cli_command ("reverse-nexti", argv
+ 1, argc
- 1);
180 mi_execute_async_cli_command ("nexti", argv
, argc
);
184 mi_cmd_exec_step (const char *command
, char **argv
, int argc
)
186 /* FIXME: Should call a libgdb function, not a cli wrapper. */
187 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
188 mi_execute_async_cli_command ("reverse-step", argv
+ 1, argc
- 1);
190 mi_execute_async_cli_command ("step", argv
, argc
);
194 mi_cmd_exec_step_instruction (const char *command
, char **argv
, int argc
)
196 /* FIXME: Should call a libgdb function, not a cli wrapper. */
197 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
198 mi_execute_async_cli_command ("reverse-stepi", argv
+ 1, argc
- 1);
200 mi_execute_async_cli_command ("stepi", argv
, argc
);
204 mi_cmd_exec_finish (const char *command
, char **argv
, int argc
)
206 /* FIXME: Should call a libgdb function, not a cli wrapper. */
207 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
208 mi_execute_async_cli_command ("reverse-finish", argv
+ 1, argc
- 1);
210 mi_execute_async_cli_command ("finish", argv
, argc
);
214 mi_cmd_exec_return (const char *command
, char **argv
, int argc
)
216 /* This command doesn't really execute the target, it just pops the
217 specified number of frames. */
219 /* Call return_command with from_tty argument equal to 0 so as to
220 avoid being queried. */
221 return_command (*argv
, 0);
223 /* Call return_command with from_tty argument equal to 0 so as to
224 avoid being queried. */
225 return_command (NULL
, 0);
227 /* Because we have called return_command with from_tty = 0, we need
228 to print the frame here. */
229 print_stack_frame (get_selected_frame (NULL
), 1, LOC_AND_ADDRESS
, 1);
233 mi_cmd_exec_jump (const char *args
, char **argv
, int argc
)
235 /* FIXME: Should call a libgdb function, not a cli wrapper. */
236 mi_execute_async_cli_command ("jump", argv
, argc
);
240 proceed_thread (struct thread_info
*thread
, int pid
)
242 if (!is_stopped (thread
->ptid
))
245 if (pid
!= 0 && ptid_get_pid (thread
->ptid
) != pid
)
248 switch_to_thread (thread
->ptid
);
249 clear_proceed_status (0);
250 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
);
254 proceed_thread_callback (struct thread_info
*thread
, void *arg
)
256 int pid
= *(int *)arg
;
258 proceed_thread (thread
, pid
);
263 exec_continue (char **argv
, int argc
)
265 prepare_execution_command (¤t_target
, mi_async_p ());
269 /* In non-stop mode, 'resume' always resumes a single thread.
270 Therefore, to resume all threads of the current inferior, or
271 all threads in all inferiors, we need to iterate over
274 See comment on infcmd.c:proceed_thread_callback for rationale. */
275 if (current_context
->all
|| current_context
->thread_group
!= -1)
278 struct cleanup
*back_to
= make_cleanup_restore_current_thread ();
280 if (!current_context
->all
)
283 = find_inferior_id (current_context
->thread_group
);
287 iterate_over_threads (proceed_thread_callback
, &pid
);
288 do_cleanups (back_to
);
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 struct cleanup
*back_to
= save_current_space_and_thread ();
473 iterate_over_inferiors (run_one_inferior
, &start_p
);
474 do_cleanups (back_to
);
478 const char *run_cmd
= start_p
? "start" : "run";
479 struct target_ops
*run_target
= find_run_target ();
480 int async_p
= mi_async
&& run_target
->to_can_async_p (run_target
);
482 mi_execute_cli_command (run_cmd
, async_p
,
483 async_p
? "&" : NULL
);
489 find_thread_of_process (struct thread_info
*ti
, void *p
)
493 if (ptid_get_pid (ti
->ptid
) == pid
&& !is_exited (ti
->ptid
))
500 mi_cmd_target_detach (const char *command
, char **argv
, int argc
)
502 if (argc
!= 0 && argc
!= 1)
503 error (_("Usage: -target-detach [pid | thread-group]"));
507 struct thread_info
*tp
;
511 /* First see if we are dealing with a thread-group id. */
514 struct inferior
*inf
;
515 int id
= strtoul (argv
[0] + 1, &end
, 0);
518 error (_("Invalid syntax of thread-group id '%s'"), argv
[0]);
520 inf
= find_inferior_id (id
);
522 error (_("Non-existent thread-group id '%d'"), id
);
528 /* We must be dealing with a pid. */
529 pid
= strtol (argv
[0], &end
, 10);
532 error (_("Invalid identifier '%s'"), argv
[0]);
535 /* Pick any thread in the desired process. Current
536 target_detach detaches from the parent of inferior_ptid. */
537 tp
= iterate_over_threads (find_thread_of_process
, &pid
);
539 error (_("Thread group is empty"));
541 switch_to_thread (tp
->ptid
);
544 detach_command (NULL
, 0);
548 mi_cmd_target_flash_erase (const char *command
, char **argv
, int argc
)
550 flash_erase_command (NULL
, 0);
554 mi_cmd_thread_select (const char *command
, char **argv
, int argc
)
557 char *mi_error_message
;
558 ptid_t previous_ptid
= inferior_ptid
;
561 error (_("-thread-select: USAGE: threadnum."));
563 rc
= gdb_thread_select (current_uiout
, argv
[0], &mi_error_message
);
565 /* If thread switch did not succeed don't notify or print. */
566 if (rc
== GDB_RC_FAIL
)
568 make_cleanup (xfree
, mi_error_message
);
569 error ("%s", mi_error_message
);
572 print_selected_thread_frame (current_uiout
,
573 USER_SELECTED_THREAD
| USER_SELECTED_FRAME
);
575 /* Notify if the thread has effectively changed. */
576 if (!ptid_equal (inferior_ptid
, previous_ptid
))
578 observer_notify_user_selected_context_changed (USER_SELECTED_THREAD
579 | USER_SELECTED_FRAME
);
584 mi_cmd_thread_list_ids (const char *command
, char **argv
, int argc
)
587 char *mi_error_message
;
590 error (_("-thread-list-ids: No arguments required."));
592 rc
= gdb_list_thread_ids (current_uiout
, &mi_error_message
);
594 if (rc
== GDB_RC_FAIL
)
596 make_cleanup (xfree
, mi_error_message
);
597 error ("%s", mi_error_message
);
602 mi_cmd_thread_info (const char *command
, char **argv
, int argc
)
604 if (argc
!= 0 && argc
!= 1)
605 error (_("Invalid MI command"));
607 print_thread_info (current_uiout
, argv
[0], -1);
610 struct collect_cores_data
618 collect_cores (struct thread_info
*ti
, void *xdata
)
620 struct collect_cores_data
*data
= (struct collect_cores_data
*) xdata
;
622 if (ptid_get_pid (ti
->ptid
) == data
->pid
)
624 int core
= target_core_of_thread (ti
->ptid
);
627 VEC_safe_push (int, data
->cores
, core
);
634 unique (int *b
, int *e
)
644 struct print_one_inferior_data
647 VEC (int) *inferiors
;
651 print_one_inferior (struct inferior
*inferior
, void *xdata
)
653 struct print_one_inferior_data
*top_data
654 = (struct print_one_inferior_data
*) xdata
;
655 struct ui_out
*uiout
= current_uiout
;
657 if (VEC_empty (int, top_data
->inferiors
)
658 || bsearch (&(inferior
->pid
), VEC_address (int, top_data
->inferiors
),
659 VEC_length (int, top_data
->inferiors
), sizeof (int),
660 compare_positive_ints
))
662 struct collect_cores_data data
;
663 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
665 uiout
->field_fmt ("id", "i%d", inferior
->num
);
666 uiout
->field_string ("type", "process");
667 if (inferior
->has_exit_code
)
668 uiout
->field_string ("exit-code",
669 int_string (inferior
->exit_code
, 8, 0, 0, 1));
670 if (inferior
->pid
!= 0)
671 uiout
->field_int ("pid", inferior
->pid
);
673 if (inferior
->pspace
->pspace_exec_filename
!= NULL
)
675 uiout
->field_string ("executable",
676 inferior
->pspace
->pspace_exec_filename
);
680 if (inferior
->pid
!= 0)
682 data
.pid
= inferior
->pid
;
683 iterate_over_threads (collect_cores
, &data
);
686 if (!VEC_empty (int, data
.cores
))
689 struct cleanup
*back_to_2
=
690 make_cleanup_ui_out_list_begin_end (uiout
, "cores");
692 qsort (VEC_address (int, data
.cores
),
693 VEC_length (int, data
.cores
), sizeof (int),
694 compare_positive_ints
);
696 b
= VEC_address (int, data
.cores
);
697 e
= b
+ VEC_length (int, data
.cores
);
701 uiout
->field_int (NULL
, *b
);
703 do_cleanups (back_to_2
);
706 if (top_data
->recurse
)
707 print_thread_info (uiout
, NULL
, inferior
->pid
);
713 /* Output a field named 'cores' with a list as the value. The
714 elements of the list are obtained by splitting 'cores' on
718 output_cores (struct ui_out
*uiout
, const char *field_name
, const char *xcores
)
720 struct cleanup
*back_to
= make_cleanup_ui_out_list_begin_end (uiout
,
722 char *cores
= xstrdup (xcores
);
725 make_cleanup (xfree
, cores
);
727 for (p
= strtok (p
, ","); p
; p
= strtok (NULL
, ","))
728 uiout
->field_string (NULL
, p
);
730 do_cleanups (back_to
);
734 free_vector_of_ints (void *xvector
)
736 VEC (int) **vector
= (VEC (int) **) xvector
;
738 VEC_free (int, *vector
);
742 do_nothing (splay_tree_key k
)
747 free_vector_of_osdata_items (splay_tree_value xvalue
)
749 VEC (osdata_item_s
) *value
= (VEC (osdata_item_s
) *) xvalue
;
751 /* We don't free the items itself, it will be done separately. */
752 VEC_free (osdata_item_s
, value
);
756 splay_tree_int_comparator (splay_tree_key xa
, splay_tree_key xb
)
765 free_splay_tree (void *xt
)
767 splay_tree t
= (splay_tree
) xt
;
768 splay_tree_delete (t
);
772 list_available_thread_groups (VEC (int) *ids
, int recurse
)
775 struct osdata_item
*item
;
777 struct ui_out
*uiout
= current_uiout
;
778 struct cleanup
*cleanup
;
780 /* This keeps a map from integer (pid) to VEC (struct osdata_item *)*
781 The vector contains information about all threads for the given pid.
782 This is assigned an initial value to avoid "may be used uninitialized"
784 splay_tree tree
= NULL
;
786 /* get_osdata will throw if it cannot return data. */
787 data
= get_osdata ("processes");
788 cleanup
= make_cleanup_osdata_free (data
);
792 struct osdata
*threads
= get_osdata ("threads");
794 make_cleanup_osdata_free (threads
);
795 tree
= splay_tree_new (splay_tree_int_comparator
,
797 free_vector_of_osdata_items
);
798 make_cleanup (free_splay_tree
, tree
);
801 VEC_iterate (osdata_item_s
, threads
->items
,
805 const char *pid
= get_osdata_column (item
, "pid");
806 int pid_i
= strtoul (pid
, NULL
, 0);
807 VEC (osdata_item_s
) *vec
= 0;
809 splay_tree_node n
= splay_tree_lookup (tree
, pid_i
);
812 VEC_safe_push (osdata_item_s
, vec
, item
);
813 splay_tree_insert (tree
, pid_i
, (splay_tree_value
)vec
);
817 vec
= (VEC (osdata_item_s
) *) n
->value
;
818 VEC_safe_push (osdata_item_s
, vec
, item
);
819 n
->value
= (splay_tree_value
) vec
;
824 make_cleanup_ui_out_list_begin_end (uiout
, "groups");
827 VEC_iterate (osdata_item_s
, data
->items
,
831 const char *pid
= get_osdata_column (item
, "pid");
832 const char *cmd
= get_osdata_column (item
, "command");
833 const char *user
= get_osdata_column (item
, "user");
834 const char *cores
= get_osdata_column (item
, "cores");
836 int pid_i
= strtoul (pid
, NULL
, 0);
838 /* At present, the target will return all available processes
839 and if information about specific ones was required, we filter
840 undesired processes here. */
841 if (ids
&& bsearch (&pid_i
, VEC_address (int, ids
),
842 VEC_length (int, ids
),
843 sizeof (int), compare_positive_ints
) == NULL
)
847 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
849 uiout
->field_fmt ("id", "%s", pid
);
850 uiout
->field_string ("type", "process");
852 uiout
->field_string ("description", cmd
);
854 uiout
->field_string ("user", user
);
856 output_cores (uiout
, "cores", cores
);
860 splay_tree_node n
= splay_tree_lookup (tree
, pid_i
);
863 VEC (osdata_item_s
) *children
= (VEC (osdata_item_s
) *) n
->value
;
864 struct osdata_item
*child
;
867 make_cleanup_ui_out_list_begin_end (uiout
, "threads");
870 VEC_iterate (osdata_item_s
, children
, ix_child
, child
);
873 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
874 const char *tid
= get_osdata_column (child
, "tid");
875 const char *tcore
= get_osdata_column (child
, "core");
877 uiout
->field_string ("id", tid
);
879 uiout
->field_string ("core", tcore
);
885 do_cleanups (cleanup
);
889 mi_cmd_list_thread_groups (const char *command
, char **argv
, int argc
)
891 struct ui_out
*uiout
= current_uiout
;
892 struct cleanup
*back_to
;
899 AVAILABLE_OPT
, RECURSE_OPT
901 static const struct mi_opt opts
[] =
903 {"-available", AVAILABLE_OPT
, 0},
904 {"-recurse", RECURSE_OPT
, 1},
913 int opt
= mi_getopt ("-list-thread-groups", argc
, argv
, opts
,
918 switch ((enum opt
) opt
)
924 if (strcmp (oarg
, "0") == 0)
926 else if (strcmp (oarg
, "1") == 0)
929 error (_("only '0' and '1' are valid values "
930 "for the '--recurse' option"));
935 for (; oind
< argc
; ++oind
)
940 if (*(argv
[oind
]) != 'i')
941 error (_("invalid syntax of group id '%s'"), argv
[oind
]);
943 inf
= strtoul (argv
[oind
] + 1, &end
, 0);
946 error (_("invalid syntax of group id '%s'"), argv
[oind
]);
947 VEC_safe_push (int, ids
, inf
);
949 if (VEC_length (int, ids
) > 1)
950 qsort (VEC_address (int, ids
),
951 VEC_length (int, ids
),
952 sizeof (int), compare_positive_ints
);
954 back_to
= make_cleanup (free_vector_of_ints
, &ids
);
958 list_available_thread_groups (ids
, recurse
);
960 else if (VEC_length (int, ids
) == 1)
962 /* Local thread groups, single id. */
963 int id
= *VEC_address (int, ids
);
964 struct inferior
*inf
= find_inferior_id (id
);
967 error (_("Non-existent thread group id '%d'"), id
);
969 print_thread_info (uiout
, NULL
, inf
->pid
);
973 struct print_one_inferior_data data
;
975 data
.recurse
= recurse
;
976 data
.inferiors
= ids
;
978 /* Local thread groups. Either no explicit ids -- and we
979 print everything, or several explicit ids. In both cases,
980 we print more than one group, and have to use 'groups'
981 as the top-level element. */
982 make_cleanup_ui_out_list_begin_end (uiout
, "groups");
983 update_thread_list ();
984 iterate_over_inferiors (print_one_inferior
, &data
);
987 do_cleanups (back_to
);
991 mi_cmd_data_list_register_names (const char *command
, char **argv
, int argc
)
993 struct gdbarch
*gdbarch
;
994 struct ui_out
*uiout
= current_uiout
;
997 struct cleanup
*cleanup
;
999 /* Note that the test for a valid register must include checking the
1000 gdbarch_register_name because gdbarch_num_regs may be allocated
1001 for the union of the register sets within a family of related
1002 processors. In this case, some entries of gdbarch_register_name
1003 will change depending upon the particular processor being
1006 gdbarch
= get_current_arch ();
1007 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1009 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "register-names");
1011 if (argc
== 0) /* No args, just do all the regs. */
1017 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1018 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1019 uiout
->field_string (NULL
, "");
1021 uiout
->field_string (NULL
, gdbarch_register_name (gdbarch
, regnum
));
1025 /* Else, list of register #s, just do listed regs. */
1026 for (i
= 0; i
< argc
; i
++)
1028 regnum
= atoi (argv
[i
]);
1029 if (regnum
< 0 || regnum
>= numregs
)
1030 error (_("bad register number"));
1032 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1033 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1034 uiout
->field_string (NULL
, "");
1036 uiout
->field_string (NULL
, gdbarch_register_name (gdbarch
, regnum
));
1038 do_cleanups (cleanup
);
1042 mi_cmd_data_list_changed_registers (const char *command
, char **argv
, int argc
)
1044 static struct regcache
*this_regs
= NULL
;
1045 struct ui_out
*uiout
= current_uiout
;
1046 struct regcache
*prev_regs
;
1047 struct gdbarch
*gdbarch
;
1048 int regnum
, numregs
, changed
;
1050 struct cleanup
*cleanup
;
1052 /* The last time we visited this function, the current frame's
1053 register contents were saved in THIS_REGS. Move THIS_REGS over
1054 to PREV_REGS, and refresh THIS_REGS with the now-current register
1057 prev_regs
= this_regs
;
1058 this_regs
= frame_save_as_regcache (get_selected_frame (NULL
));
1059 cleanup
= make_cleanup_regcache_xfree (prev_regs
);
1061 /* Note that the test for a valid register must include checking the
1062 gdbarch_register_name because gdbarch_num_regs may be allocated
1063 for the union of the register sets within a family of related
1064 processors. In this case, some entries of gdbarch_register_name
1065 will change depending upon the particular processor being
1068 gdbarch
= get_regcache_arch (this_regs
);
1069 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1071 make_cleanup_ui_out_list_begin_end (uiout
, "changed-registers");
1075 /* No args, just do all the regs. */
1080 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1081 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1083 changed
= register_changed_p (regnum
, prev_regs
, this_regs
);
1085 error (_("-data-list-changed-registers: "
1086 "Unable to read register contents."));
1088 uiout
->field_int (NULL
, regnum
);
1092 /* Else, list of register #s, just do listed regs. */
1093 for (i
= 0; i
< argc
; i
++)
1095 regnum
= atoi (argv
[i
]);
1099 && gdbarch_register_name (gdbarch
, regnum
) != NULL
1100 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
1102 changed
= register_changed_p (regnum
, prev_regs
, this_regs
);
1104 error (_("-data-list-changed-registers: "
1105 "Unable to read register contents."));
1107 uiout
->field_int (NULL
, regnum
);
1110 error (_("bad register number"));
1112 do_cleanups (cleanup
);
1116 register_changed_p (int regnum
, struct regcache
*prev_regs
,
1117 struct regcache
*this_regs
)
1119 struct gdbarch
*gdbarch
= get_regcache_arch (this_regs
);
1120 gdb_byte prev_buffer
[MAX_REGISTER_SIZE
];
1121 gdb_byte this_buffer
[MAX_REGISTER_SIZE
];
1122 enum register_status prev_status
;
1123 enum register_status this_status
;
1125 /* First time through or after gdbarch change consider all registers
1127 if (!prev_regs
|| get_regcache_arch (prev_regs
) != gdbarch
)
1130 /* Get register contents and compare. */
1131 prev_status
= regcache_cooked_read (prev_regs
, regnum
, prev_buffer
);
1132 this_status
= regcache_cooked_read (this_regs
, regnum
, this_buffer
);
1134 if (this_status
!= prev_status
)
1136 else if (this_status
== REG_VALID
)
1137 return memcmp (prev_buffer
, this_buffer
,
1138 register_size (gdbarch
, regnum
)) != 0;
1143 /* Return a list of register number and value pairs. The valid
1144 arguments expected are: a letter indicating the format in which to
1145 display the registers contents. This can be one of: x
1146 (hexadecimal), d (decimal), N (natural), t (binary), o (octal), r
1147 (raw). After the format argument there can be a sequence of
1148 numbers, indicating which registers to fetch the content of. If
1149 the format is the only argument, a list of all the registers with
1150 their values is returned. */
1153 mi_cmd_data_list_register_values (const char *command
, char **argv
, int argc
)
1155 struct ui_out
*uiout
= current_uiout
;
1156 struct frame_info
*frame
;
1157 struct gdbarch
*gdbarch
;
1158 int regnum
, numregs
, format
;
1160 struct cleanup
*list_cleanup
;
1161 int skip_unavailable
= 0;
1167 static const struct mi_opt opts
[] =
1169 {"-skip-unavailable", SKIP_UNAVAILABLE
, 0},
1173 /* Note that the test for a valid register must include checking the
1174 gdbarch_register_name because gdbarch_num_regs may be allocated
1175 for the union of the register sets within a family of related
1176 processors. In this case, some entries of gdbarch_register_name
1177 will change depending upon the particular processor being
1183 int opt
= mi_getopt ("-data-list-register-values", argc
, argv
,
1184 opts
, &oind
, &oarg
);
1188 switch ((enum opt
) opt
)
1190 case SKIP_UNAVAILABLE
:
1191 skip_unavailable
= 1;
1196 if (argc
- oind
< 1)
1197 error (_("-data-list-register-values: Usage: "
1198 "-data-list-register-values [--skip-unavailable] <format>"
1199 " [<regnum1>...<regnumN>]"));
1201 format
= (int) argv
[oind
][0];
1203 frame
= get_selected_frame (NULL
);
1204 gdbarch
= get_frame_arch (frame
);
1205 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1207 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "register-values");
1209 if (argc
- oind
== 1)
1211 /* No args, beside the format: do all the regs. */
1216 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1217 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1220 output_register (frame
, regnum
, format
, skip_unavailable
);
1224 /* Else, list of register #s, just do listed regs. */
1225 for (i
= 1 + oind
; i
< argc
; i
++)
1227 regnum
= atoi (argv
[i
]);
1231 && gdbarch_register_name (gdbarch
, regnum
) != NULL
1232 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
1233 output_register (frame
, regnum
, format
, skip_unavailable
);
1235 error (_("bad register number"));
1237 do_cleanups (list_cleanup
);
1240 /* Output one register REGNUM's contents in the desired FORMAT. If
1241 SKIP_UNAVAILABLE is true, skip the register if it is
1245 output_register (struct frame_info
*frame
, int regnum
, int format
,
1246 int skip_unavailable
)
1248 struct ui_out
*uiout
= current_uiout
;
1249 struct value
*val
= value_of_register (regnum
, frame
);
1250 struct value_print_options opts
;
1252 if (skip_unavailable
&& !value_entirely_available (val
))
1255 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1256 uiout
->field_int ("number", regnum
);
1266 get_formatted_print_options (&opts
, format
);
1268 val_print (value_type (val
),
1269 value_embedded_offset (val
), 0,
1270 &stb
, 0, val
, &opts
, current_language
);
1271 uiout
->field_stream ("value", stb
);
1274 /* Write given values into registers. The registers and values are
1275 given as pairs. The corresponding MI command is
1276 -data-write-register-values <format>
1277 [<regnum1> <value1>...<regnumN> <valueN>] */
1279 mi_cmd_data_write_register_values (const char *command
, char **argv
, int argc
)
1281 struct regcache
*regcache
;
1282 struct gdbarch
*gdbarch
;
1285 /* Note that the test for a valid register must include checking the
1286 gdbarch_register_name because gdbarch_num_regs may be allocated
1287 for the union of the register sets within a family of related
1288 processors. In this case, some entries of gdbarch_register_name
1289 will change depending upon the particular processor being
1292 regcache
= get_current_regcache ();
1293 gdbarch
= get_regcache_arch (regcache
);
1294 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1297 error (_("-data-write-register-values: Usage: -data-write-register-"
1298 "values <format> [<regnum1> <value1>...<regnumN> <valueN>]"));
1300 if (!target_has_registers
)
1301 error (_("-data-write-register-values: No registers."));
1304 error (_("-data-write-register-values: No regs and values specified."));
1307 error (_("-data-write-register-values: "
1308 "Regs and vals are not in pairs."));
1310 for (i
= 1; i
< argc
; i
= i
+ 2)
1312 int regnum
= atoi (argv
[i
]);
1314 if (regnum
>= 0 && regnum
< numregs
1315 && gdbarch_register_name (gdbarch
, regnum
)
1316 && *gdbarch_register_name (gdbarch
, regnum
))
1320 /* Get the value as a number. */
1321 value
= parse_and_eval_address (argv
[i
+ 1]);
1323 /* Write it down. */
1324 regcache_cooked_write_signed (regcache
, regnum
, value
);
1327 error (_("bad register number"));
1331 /* Evaluate the value of the argument. The argument is an
1332 expression. If the expression contains spaces it needs to be
1333 included in double quotes. */
1336 mi_cmd_data_evaluate_expression (const char *command
, char **argv
, int argc
)
1339 struct value_print_options opts
;
1340 struct ui_out
*uiout
= current_uiout
;
1343 error (_("-data-evaluate-expression: "
1344 "Usage: -data-evaluate-expression expression"));
1346 expression_up expr
= parse_expression (argv
[0]);
1348 val
= evaluate_expression (expr
.get ());
1352 /* Print the result of the expression evaluation. */
1353 get_user_print_options (&opts
);
1355 common_val_print (val
, &stb
, 0, &opts
, current_language
);
1357 uiout
->field_stream ("value", stb
);
1360 /* This is the -data-read-memory command.
1362 ADDR: start address of data to be dumped.
1363 WORD-FORMAT: a char indicating format for the ``word''. See
1365 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
1366 NR_ROW: Number of rows.
1367 NR_COL: The number of colums (words per row).
1368 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
1369 ASCHAR for unprintable characters.
1371 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
1372 displayes them. Returns:
1374 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
1377 The number of bytes read is SIZE*ROW*COL. */
1380 mi_cmd_data_read_memory (const char *command
, char **argv
, int argc
)
1382 struct gdbarch
*gdbarch
= get_current_arch ();
1383 struct ui_out
*uiout
= current_uiout
;
1385 long total_bytes
, nr_cols
, nr_rows
;
1387 struct type
*word_type
;
1399 static const struct mi_opt opts
[] =
1401 {"o", OFFSET_OPT
, 1},
1407 int opt
= mi_getopt ("-data-read-memory", argc
, argv
, opts
,
1412 switch ((enum opt
) opt
)
1415 offset
= atol (oarg
);
1422 if (argc
< 5 || argc
> 6)
1423 error (_("-data-read-memory: Usage: "
1424 "ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR]."));
1426 /* Extract all the arguments. */
1428 /* Start address of the memory dump. */
1429 addr
= parse_and_eval_address (argv
[0]) + offset
;
1430 /* The format character to use when displaying a memory word. See
1431 the ``x'' command. */
1432 word_format
= argv
[1][0];
1433 /* The size of the memory word. */
1434 word_size
= atol (argv
[2]);
1438 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1442 word_type
= builtin_type (gdbarch
)->builtin_int16
;
1446 word_type
= builtin_type (gdbarch
)->builtin_int32
;
1450 word_type
= builtin_type (gdbarch
)->builtin_int64
;
1454 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1457 /* The number of rows. */
1458 nr_rows
= atol (argv
[3]);
1460 error (_("-data-read-memory: invalid number of rows."));
1462 /* Number of bytes per row. */
1463 nr_cols
= atol (argv
[4]);
1465 error (_("-data-read-memory: invalid number of columns."));
1467 /* The un-printable character when printing ascii. */
1473 /* Create a buffer and read it in. */
1474 total_bytes
= word_size
* nr_rows
* nr_cols
;
1476 std::unique_ptr
<gdb_byte
[]> mbuf (new gdb_byte
[total_bytes
]);
1478 /* Dispatch memory reads to the topmost target, not the flattened
1480 nr_bytes
= target_read (current_target
.beneath
,
1481 TARGET_OBJECT_MEMORY
, NULL
, mbuf
.get (),
1484 error (_("Unable to read memory."));
1486 /* Output the header information. */
1487 uiout
->field_core_addr ("addr", gdbarch
, addr
);
1488 uiout
->field_int ("nr-bytes", nr_bytes
);
1489 uiout
->field_int ("total-bytes", total_bytes
);
1490 uiout
->field_core_addr ("next-row", gdbarch
, addr
+ word_size
* nr_cols
);
1491 uiout
->field_core_addr ("prev-row", gdbarch
, addr
- word_size
* nr_cols
);
1492 uiout
->field_core_addr ("next-page", gdbarch
, addr
+ total_bytes
);
1493 uiout
->field_core_addr ("prev-page", gdbarch
, addr
- total_bytes
);
1495 /* Build the result as a two dimentional table. */
1499 struct cleanup
*cleanup_list
;
1503 cleanup_list
= make_cleanup_ui_out_list_begin_end (uiout
, "memory");
1504 for (row
= 0, row_byte
= 0;
1506 row
++, row_byte
+= nr_cols
* word_size
)
1510 struct cleanup
*cleanup_list_data
;
1511 struct value_print_options opts
;
1513 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1514 uiout
->field_core_addr ("addr", gdbarch
, addr
+ row_byte
);
1515 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr +
1517 cleanup_list_data
= make_cleanup_ui_out_list_begin_end (uiout
, "data");
1518 get_formatted_print_options (&opts
, word_format
);
1519 for (col
= 0, col_byte
= row_byte
;
1521 col
++, col_byte
+= word_size
)
1523 if (col_byte
+ word_size
> nr_bytes
)
1525 uiout
->field_string (NULL
, "N/A");
1530 print_scalar_formatted (&mbuf
[col_byte
], word_type
, &opts
,
1531 word_asize
, &stream
);
1532 uiout
->field_stream (NULL
, stream
);
1535 do_cleanups (cleanup_list_data
);
1541 for (byte
= row_byte
;
1542 byte
< row_byte
+ word_size
* nr_cols
; byte
++)
1544 if (byte
>= nr_bytes
)
1546 else if (mbuf
[byte
] < 32 || mbuf
[byte
] > 126)
1547 stream
.putc (aschar
);
1549 stream
.putc (mbuf
[byte
]);
1551 uiout
->field_stream ("ascii", stream
);
1554 do_cleanups (cleanup_list
);
1559 mi_cmd_data_read_memory_bytes (const char *command
, char **argv
, int argc
)
1561 struct gdbarch
*gdbarch
= get_current_arch ();
1562 struct ui_out
*uiout
= current_uiout
;
1563 struct cleanup
*cleanups
;
1566 memory_read_result_s
*read_result
;
1568 VEC(memory_read_result_s
) *result
;
1570 int unit_size
= gdbarch_addressable_memory_unit_size (gdbarch
);
1577 static const struct mi_opt opts
[] =
1579 {"o", OFFSET_OPT
, 1},
1585 int opt
= mi_getopt ("-data-read-memory-bytes", argc
, argv
, opts
,
1589 switch ((enum opt
) opt
)
1592 offset
= atol (oarg
);
1600 error (_("Usage: [ -o OFFSET ] ADDR LENGTH."));
1602 addr
= parse_and_eval_address (argv
[0]) + offset
;
1603 length
= atol (argv
[1]);
1605 result
= read_memory_robust (current_target
.beneath
, addr
, length
);
1607 cleanups
= make_cleanup (free_memory_read_result_vector
, &result
);
1609 if (VEC_length (memory_read_result_s
, result
) == 0)
1610 error (_("Unable to read memory."));
1612 make_cleanup_ui_out_list_begin_end (uiout
, "memory");
1614 VEC_iterate (memory_read_result_s
, result
, ix
, read_result
);
1617 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1622 uiout
->field_core_addr ("begin", gdbarch
, read_result
->begin
);
1623 uiout
->field_core_addr ("offset", gdbarch
, read_result
->begin
- addr
);
1624 uiout
->field_core_addr ("end", gdbarch
, read_result
->end
);
1626 alloc_len
= (read_result
->end
- read_result
->begin
) * 2 * unit_size
+ 1;
1627 data
= (char *) xmalloc (alloc_len
);
1629 for (i
= 0, p
= data
;
1630 i
< ((read_result
->end
- read_result
->begin
) * unit_size
);
1633 sprintf (p
, "%02x", read_result
->data
[i
]);
1635 uiout
->field_string ("contents", data
);
1638 do_cleanups (cleanups
);
1641 /* Implementation of the -data-write_memory command.
1643 COLUMN_OFFSET: optional argument. Must be preceded by '-o'. The
1644 offset from the beginning of the memory grid row where the cell to
1646 ADDR: start address of the row in the memory grid where the memory
1647 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
1648 the location to write to.
1649 FORMAT: a char indicating format for the ``word''. See
1651 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
1652 VALUE: value to be written into the memory address.
1654 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1659 mi_cmd_data_write_memory (const char *command
, char **argv
, int argc
)
1661 struct gdbarch
*gdbarch
= get_current_arch ();
1662 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1665 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1666 enough when using a compiler other than GCC. */
1669 struct cleanup
*old_chain
;
1677 static const struct mi_opt opts
[] =
1679 {"o", OFFSET_OPT
, 1},
1685 int opt
= mi_getopt ("-data-write-memory", argc
, argv
, opts
,
1690 switch ((enum opt
) opt
)
1693 offset
= atol (oarg
);
1701 error (_("-data-write-memory: Usage: "
1702 "[-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE."));
1704 /* Extract all the arguments. */
1705 /* Start address of the memory dump. */
1706 addr
= parse_and_eval_address (argv
[0]);
1707 /* The size of the memory word. */
1708 word_size
= atol (argv
[2]);
1710 /* Calculate the real address of the write destination. */
1711 addr
+= (offset
* word_size
);
1713 /* Get the value as a number. */
1714 value
= parse_and_eval_address (argv
[3]);
1715 /* Get the value into an array. */
1716 buffer
= (gdb_byte
*) xmalloc (word_size
);
1717 old_chain
= make_cleanup (xfree
, buffer
);
1718 store_signed_integer (buffer
, word_size
, byte_order
, value
);
1719 /* Write it down to memory. */
1720 write_memory_with_notification (addr
, buffer
, word_size
);
1721 /* Free the buffer. */
1722 do_cleanups (old_chain
);
1725 /* Implementation of the -data-write-memory-bytes command.
1728 DATA: string of bytes to write at that address
1729 COUNT: number of bytes to be filled (decimal integer). */
1732 mi_cmd_data_write_memory_bytes (const char *command
, char **argv
, int argc
)
1738 size_t len_hex
, len_bytes
, len_units
, i
, steps
, remaining_units
;
1739 long int count_units
;
1740 struct cleanup
*back_to
;
1743 if (argc
!= 2 && argc
!= 3)
1744 error (_("Usage: ADDR DATA [COUNT]."));
1746 addr
= parse_and_eval_address (argv
[0]);
1748 len_hex
= strlen (cdata
);
1749 unit_size
= gdbarch_addressable_memory_unit_size (get_current_arch ());
1751 if (len_hex
% (unit_size
* 2) != 0)
1752 error (_("Hex-encoded '%s' must represent an integral number of "
1753 "addressable memory units."),
1756 len_bytes
= len_hex
/ 2;
1757 len_units
= len_bytes
/ unit_size
;
1760 count_units
= strtoul (argv
[2], NULL
, 10);
1762 count_units
= len_units
;
1764 databuf
= XNEWVEC (gdb_byte
, len_bytes
);
1765 back_to
= make_cleanup (xfree
, databuf
);
1767 for (i
= 0; i
< len_bytes
; ++i
)
1770 if (sscanf (cdata
+ i
* 2, "%02x", &x
) != 1)
1771 error (_("Invalid argument"));
1772 databuf
[i
] = (gdb_byte
) x
;
1775 if (len_units
< count_units
)
1777 /* Pattern is made of less units than count:
1778 repeat pattern to fill memory. */
1779 data
= (gdb_byte
*) xmalloc (count_units
* unit_size
);
1780 make_cleanup (xfree
, data
);
1782 /* Number of times the pattern is entirely repeated. */
1783 steps
= count_units
/ len_units
;
1784 /* Number of remaining addressable memory units. */
1785 remaining_units
= count_units
% len_units
;
1786 for (i
= 0; i
< steps
; i
++)
1787 memcpy (data
+ i
* len_bytes
, databuf
, len_bytes
);
1789 if (remaining_units
> 0)
1790 memcpy (data
+ steps
* len_bytes
, databuf
,
1791 remaining_units
* unit_size
);
1795 /* Pattern is longer than or equal to count:
1796 just copy count addressable memory units. */
1800 write_memory_with_notification (addr
, data
, count_units
);
1802 do_cleanups (back_to
);
1806 mi_cmd_enable_timings (const char *command
, char **argv
, int argc
)
1812 if (strcmp (argv
[0], "yes") == 0)
1814 else if (strcmp (argv
[0], "no") == 0)
1825 error (_("-enable-timings: Usage: %s {yes|no}"), command
);
1829 mi_cmd_list_features (const char *command
, char **argv
, int argc
)
1833 struct cleanup
*cleanup
= NULL
;
1834 struct ui_out
*uiout
= current_uiout
;
1836 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "features");
1837 uiout
->field_string (NULL
, "frozen-varobjs");
1838 uiout
->field_string (NULL
, "pending-breakpoints");
1839 uiout
->field_string (NULL
, "thread-info");
1840 uiout
->field_string (NULL
, "data-read-memory-bytes");
1841 uiout
->field_string (NULL
, "breakpoint-notifications");
1842 uiout
->field_string (NULL
, "ada-task-info");
1843 uiout
->field_string (NULL
, "language-option");
1844 uiout
->field_string (NULL
, "info-gdb-mi-command");
1845 uiout
->field_string (NULL
, "undefined-command-error-code");
1846 uiout
->field_string (NULL
, "exec-run-start-option");
1848 if (ext_lang_initialized_p (get_ext_lang_defn (EXT_LANG_PYTHON
)))
1849 uiout
->field_string (NULL
, "python");
1851 do_cleanups (cleanup
);
1855 error (_("-list-features should be passed no arguments"));
1859 mi_cmd_list_target_features (const char *command
, char **argv
, int argc
)
1863 struct cleanup
*cleanup
= NULL
;
1864 struct ui_out
*uiout
= current_uiout
;
1866 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "features");
1868 uiout
->field_string (NULL
, "async");
1869 if (target_can_execute_reverse
)
1870 uiout
->field_string (NULL
, "reverse");
1871 do_cleanups (cleanup
);
1875 error (_("-list-target-features should be passed no arguments"));
1879 mi_cmd_add_inferior (const char *command
, char **argv
, int argc
)
1881 struct inferior
*inf
;
1884 error (_("-add-inferior should be passed no arguments"));
1886 inf
= add_inferior_with_spaces ();
1888 current_uiout
->field_fmt ("inferior", "i%d", inf
->num
);
1891 /* Callback used to find the first inferior other than the current
1895 get_other_inferior (struct inferior
*inf
, void *arg
)
1897 if (inf
== current_inferior ())
1904 mi_cmd_remove_inferior (const char *command
, char **argv
, int argc
)
1907 struct inferior
*inf
;
1910 error (_("-remove-inferior should be passed a single argument"));
1912 if (sscanf (argv
[0], "i%d", &id
) != 1)
1913 error (_("the thread group id is syntactically invalid"));
1915 inf
= find_inferior_id (id
);
1917 error (_("the specified thread group does not exist"));
1920 error (_("cannot remove an active inferior"));
1922 if (inf
== current_inferior ())
1924 struct thread_info
*tp
= 0;
1925 struct inferior
*new_inferior
1926 = iterate_over_inferiors (get_other_inferior
, NULL
);
1928 if (new_inferior
== NULL
)
1929 error (_("Cannot remove last inferior"));
1931 set_current_inferior (new_inferior
);
1932 if (new_inferior
->pid
!= 0)
1933 tp
= any_thread_of_process (new_inferior
->pid
);
1934 switch_to_thread (tp
? tp
->ptid
: null_ptid
);
1935 set_current_program_space (new_inferior
->pspace
);
1938 delete_inferior (inf
);
1943 /* Execute a command within a safe environment.
1944 Return <0 for error; >=0 for ok.
1946 args->action will tell mi_execute_command what action
1947 to perfrom after the given command has executed (display/suppress
1948 prompt, display error). */
1951 captured_mi_execute_command (struct ui_out
*uiout
, struct mi_parse
*context
)
1953 struct mi_interp
*mi
= (struct mi_interp
*) command_interp ();
1954 struct cleanup
*cleanup
;
1957 current_command_ts
= context
->cmd_start
;
1959 current_token
= xstrdup (context
->token
);
1960 cleanup
= make_cleanup (free_current_contents
, ¤t_token
);
1962 running_result_record_printed
= 0;
1964 switch (context
->op
)
1967 /* A MI command was read from the input stream. */
1969 /* FIXME: gdb_???? */
1970 fprintf_unfiltered (mi
->raw_stdout
,
1971 " token=`%s' command=`%s' args=`%s'\n",
1972 context
->token
, context
->command
, context
->args
);
1974 mi_cmd_execute (context
);
1976 /* Print the result if there were no errors.
1978 Remember that on the way out of executing a command, you have
1979 to directly use the mi_interp's uiout, since the command
1980 could have reset the interpreter, in which case the current
1981 uiout will most likely crash in the mi_out_* routines. */
1982 if (!running_result_record_printed
)
1984 fputs_unfiltered (context
->token
, mi
->raw_stdout
);
1985 /* There's no particularly good reason why target-connect results
1986 in not ^done. Should kill ^connected for MI3. */
1987 fputs_unfiltered (strcmp (context
->command
, "target-select") == 0
1988 ? "^connected" : "^done", mi
->raw_stdout
);
1989 mi_out_put (uiout
, mi
->raw_stdout
);
1990 mi_out_rewind (uiout
);
1991 mi_print_timing_maybe (mi
->raw_stdout
);
1992 fputs_unfiltered ("\n", mi
->raw_stdout
);
1995 /* The command does not want anything to be printed. In that
1996 case, the command probably should not have written anything
1997 to uiout, but in case it has written something, discard it. */
1998 mi_out_rewind (uiout
);
2005 /* A CLI command was read from the input stream. */
2006 /* This "feature" will be removed as soon as we have a
2007 complete set of mi commands. */
2008 /* Echo the command on the console. */
2009 fprintf_unfiltered (gdb_stdlog
, "%s\n", context
->command
);
2010 /* Call the "console" interpreter. */
2011 argv
[0] = (char *) INTERP_CONSOLE
;
2012 argv
[1] = context
->command
;
2013 mi_cmd_interpreter_exec ("-interpreter-exec", argv
, 2);
2015 /* If we changed interpreters, DON'T print out anything. */
2016 if (current_interp_named_p (INTERP_MI
)
2017 || current_interp_named_p (INTERP_MI1
)
2018 || current_interp_named_p (INTERP_MI2
)
2019 || current_interp_named_p (INTERP_MI3
))
2021 if (!running_result_record_printed
)
2023 fputs_unfiltered (context
->token
, mi
->raw_stdout
);
2024 fputs_unfiltered ("^done", mi
->raw_stdout
);
2025 mi_out_put (uiout
, mi
->raw_stdout
);
2026 mi_out_rewind (uiout
);
2027 mi_print_timing_maybe (mi
->raw_stdout
);
2028 fputs_unfiltered ("\n", mi
->raw_stdout
);
2031 mi_out_rewind (uiout
);
2037 do_cleanups (cleanup
);
2040 /* Print a gdb exception to the MI output stream. */
2043 mi_print_exception (const char *token
, struct gdb_exception exception
)
2045 struct mi_interp
*mi
= (struct mi_interp
*) current_interpreter ();
2047 fputs_unfiltered (token
, mi
->raw_stdout
);
2048 fputs_unfiltered ("^error,msg=\"", mi
->raw_stdout
);
2049 if (exception
.message
== NULL
)
2050 fputs_unfiltered ("unknown error", mi
->raw_stdout
);
2052 fputstr_unfiltered (exception
.message
, '"', mi
->raw_stdout
);
2053 fputs_unfiltered ("\"", mi
->raw_stdout
);
2055 switch (exception
.error
)
2057 case UNDEFINED_COMMAND_ERROR
:
2058 fputs_unfiltered (",code=\"undefined-command\"", mi
->raw_stdout
);
2062 fputs_unfiltered ("\n", mi
->raw_stdout
);
2065 /* Determine whether the parsed command already notifies the
2066 user_selected_context_changed observer. */
2069 command_notifies_uscc_observer (struct mi_parse
*command
)
2071 if (command
->op
== CLI_COMMAND
)
2073 /* CLI commands "thread" and "inferior" already send it. */
2074 return (strncmp (command
->command
, "thread ", 7) == 0
2075 || strncmp (command
->command
, "inferior ", 9) == 0);
2077 else /* MI_COMMAND */
2079 if (strcmp (command
->command
, "interpreter-exec") == 0
2080 && command
->argc
> 1)
2082 /* "thread" and "inferior" again, but through -interpreter-exec. */
2083 return (strncmp (command
->argv
[1], "thread ", 7) == 0
2084 || strncmp (command
->argv
[1], "inferior ", 9) == 0);
2088 /* -thread-select already sends it. */
2089 return strcmp (command
->command
, "thread-select") == 0;
2094 mi_execute_command (const char *cmd
, int from_tty
)
2097 std::unique_ptr
<struct mi_parse
> command
;
2099 /* This is to handle EOF (^D). We just quit gdb. */
2100 /* FIXME: we should call some API function here. */
2102 quit_force (NULL
, from_tty
);
2104 target_log_command (cmd
);
2108 command
= mi_parse (cmd
, &token
);
2110 CATCH (exception
, RETURN_MASK_ALL
)
2112 mi_print_exception (token
, exception
);
2117 if (command
!= NULL
)
2119 ptid_t previous_ptid
= inferior_ptid
;
2121 gdb::optional
<scoped_restore_tmpl
<int>> restore_suppress
;
2123 if (command
->cmd
!= NULL
&& command
->cmd
->suppress_notification
!= NULL
)
2124 restore_suppress
.emplace (command
->cmd
->suppress_notification
, 1);
2126 command
->token
= token
;
2130 command
->cmd_start
= new mi_timestamp ();
2131 timestamp (command
->cmd_start
);
2136 captured_mi_execute_command (current_uiout
, command
.get ());
2138 CATCH (result
, RETURN_MASK_ALL
)
2140 /* Like in start_event_loop, enable input and force display
2141 of the prompt. Otherwise, any command that calls
2142 async_disable_stdin, and then throws, will leave input
2144 async_enable_stdin ();
2145 current_ui
->prompt_state
= PROMPT_NEEDED
;
2147 /* The command execution failed and error() was called
2149 mi_print_exception (command
->token
, result
);
2150 mi_out_rewind (current_uiout
);
2154 bpstat_do_actions ();
2156 if (/* The notifications are only output when the top-level
2157 interpreter (specified on the command line) is MI. */
2158 interp_ui_out (top_level_interpreter ())->is_mi_like_p ()
2159 /* Don't try report anything if there are no threads --
2160 the program is dead. */
2161 && thread_count () != 0
2162 /* If the command already reports the thread change, no need to do it
2164 && !command_notifies_uscc_observer (command
.get ()))
2166 struct mi_interp
*mi
= (struct mi_interp
*) top_level_interpreter ();
2167 int report_change
= 0;
2169 if (command
->thread
== -1)
2171 report_change
= (!ptid_equal (previous_ptid
, null_ptid
)
2172 && !ptid_equal (inferior_ptid
, previous_ptid
)
2173 && !ptid_equal (inferior_ptid
, null_ptid
));
2175 else if (!ptid_equal (inferior_ptid
, null_ptid
))
2177 struct thread_info
*ti
= inferior_thread ();
2179 report_change
= (ti
->global_num
!= command
->thread
);
2184 observer_notify_user_selected_context_changed
2185 (USER_SELECTED_THREAD
| USER_SELECTED_FRAME
);
2192 mi_cmd_execute (struct mi_parse
*parse
)
2194 struct cleanup
*cleanup
;
2196 cleanup
= prepare_execute_command ();
2198 if (parse
->all
&& parse
->thread_group
!= -1)
2199 error (_("Cannot specify --thread-group together with --all"));
2201 if (parse
->all
&& parse
->thread
!= -1)
2202 error (_("Cannot specify --thread together with --all"));
2204 if (parse
->thread_group
!= -1 && parse
->thread
!= -1)
2205 error (_("Cannot specify --thread together with --thread-group"));
2207 if (parse
->frame
!= -1 && parse
->thread
== -1)
2208 error (_("Cannot specify --frame without --thread"));
2210 if (parse
->thread_group
!= -1)
2212 struct inferior
*inf
= find_inferior_id (parse
->thread_group
);
2213 struct thread_info
*tp
= 0;
2216 error (_("Invalid thread group for the --thread-group option"));
2218 set_current_inferior (inf
);
2219 /* This behaviour means that if --thread-group option identifies
2220 an inferior with multiple threads, then a random one will be
2221 picked. This is not a problem -- frontend should always
2222 provide --thread if it wishes to operate on a specific
2225 tp
= any_live_thread_of_process (inf
->pid
);
2226 switch_to_thread (tp
? tp
->ptid
: null_ptid
);
2227 set_current_program_space (inf
->pspace
);
2230 if (parse
->thread
!= -1)
2232 struct thread_info
*tp
= find_thread_global_id (parse
->thread
);
2235 error (_("Invalid thread id: %d"), parse
->thread
);
2237 if (is_exited (tp
->ptid
))
2238 error (_("Thread id: %d has terminated"), parse
->thread
);
2240 switch_to_thread (tp
->ptid
);
2243 if (parse
->frame
!= -1)
2245 struct frame_info
*fid
;
2246 int frame
= parse
->frame
;
2248 fid
= find_relative_frame (get_current_frame (), &frame
);
2250 /* find_relative_frame was successful */
2253 error (_("Invalid frame id: %d"), frame
);
2256 if (parse
->language
!= language_unknown
)
2258 make_cleanup_restore_current_language ();
2259 set_language (parse
->language
);
2262 current_context
= parse
;
2264 if (parse
->cmd
->argv_func
!= NULL
)
2266 parse
->cmd
->argv_func (parse
->command
, parse
->argv
, parse
->argc
);
2268 else if (parse
->cmd
->cli
.cmd
!= 0)
2270 /* FIXME: DELETE THIS. */
2271 /* The operation is still implemented by a cli command. */
2272 /* Must be a synchronous one. */
2273 mi_execute_cli_command (parse
->cmd
->cli
.cmd
, parse
->cmd
->cli
.args_p
,
2278 /* FIXME: DELETE THIS. */
2281 stb
.puts ("Undefined mi command: ");
2282 stb
.putstr (parse
->command
, '"');
2283 stb
.puts (" (missing implementation)");
2287 do_cleanups (cleanup
);
2290 /* FIXME: This is just a hack so we can get some extra commands going.
2291 We don't want to channel things through the CLI, but call libgdb directly.
2292 Use only for synchronous commands. */
2295 mi_execute_cli_command (const char *cmd
, int args_p
, const char *args
)
2299 struct cleanup
*old_cleanups
;
2303 run
= xstrprintf ("%s %s", cmd
, args
);
2305 run
= xstrdup (cmd
);
2307 /* FIXME: gdb_???? */
2308 fprintf_unfiltered (gdb_stdout
, "cli=%s run=%s\n",
2310 old_cleanups
= make_cleanup (xfree
, run
);
2311 execute_command (run
, 0 /* from_tty */ );
2312 do_cleanups (old_cleanups
);
2318 mi_execute_async_cli_command (const char *cli_command
, char **argv
, int argc
)
2320 struct cleanup
*old_cleanups
;
2324 run
= xstrprintf ("%s %s&", cli_command
, argc
? *argv
: "");
2326 run
= xstrprintf ("%s %s", cli_command
, argc
? *argv
: "");
2327 old_cleanups
= make_cleanup (xfree
, run
);
2329 execute_command (run
, 0 /* from_tty */ );
2331 /* Do this before doing any printing. It would appear that some
2332 print code leaves garbage around in the buffer. */
2333 do_cleanups (old_cleanups
);
2337 mi_load_progress (const char *section_name
,
2338 unsigned long sent_so_far
,
2339 unsigned long total_section
,
2340 unsigned long total_sent
,
2341 unsigned long grand_total
)
2343 using namespace std::chrono
;
2344 static steady_clock::time_point last_update
;
2345 static char *previous_sect_name
= NULL
;
2347 struct ui_out
*saved_uiout
;
2348 struct ui_out
*uiout
;
2349 struct mi_interp
*mi
= (struct mi_interp
*) current_interpreter ();
2351 /* This function is called through deprecated_show_load_progress
2352 which means uiout may not be correct. Fix it for the duration
2353 of this function. */
2354 saved_uiout
= current_uiout
;
2356 if (current_interp_named_p (INTERP_MI
)
2357 || current_interp_named_p (INTERP_MI2
))
2358 current_uiout
= mi_out_new (2);
2359 else if (current_interp_named_p (INTERP_MI1
))
2360 current_uiout
= mi_out_new (1);
2361 else if (current_interp_named_p (INTERP_MI3
))
2362 current_uiout
= mi_out_new (3);
2366 uiout
= current_uiout
;
2368 new_section
= (previous_sect_name
?
2369 strcmp (previous_sect_name
, section_name
) : 1);
2372 xfree (previous_sect_name
);
2373 previous_sect_name
= xstrdup (section_name
);
2376 fputs_unfiltered (current_token
, mi
->raw_stdout
);
2377 fputs_unfiltered ("+download", mi
->raw_stdout
);
2379 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
2380 uiout
->field_string ("section", section_name
);
2381 uiout
->field_int ("section-size", total_section
);
2382 uiout
->field_int ("total-size", grand_total
);
2384 mi_out_put (uiout
, mi
->raw_stdout
);
2385 fputs_unfiltered ("\n", mi
->raw_stdout
);
2386 gdb_flush (mi
->raw_stdout
);
2389 steady_clock::time_point time_now
= steady_clock::now ();
2390 if (time_now
- last_update
> milliseconds (500))
2392 last_update
= time_now
;
2394 fputs_unfiltered (current_token
, mi
->raw_stdout
);
2395 fputs_unfiltered ("+download", mi
->raw_stdout
);
2397 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
2398 uiout
->field_string ("section", section_name
);
2399 uiout
->field_int ("section-sent", sent_so_far
);
2400 uiout
->field_int ("section-size", total_section
);
2401 uiout
->field_int ("total-sent", total_sent
);
2402 uiout
->field_int ("total-size", grand_total
);
2404 mi_out_put (uiout
, mi
->raw_stdout
);
2405 fputs_unfiltered ("\n", mi
->raw_stdout
);
2406 gdb_flush (mi
->raw_stdout
);
2410 current_uiout
= saved_uiout
;
2414 timestamp (struct mi_timestamp
*tv
)
2416 using namespace std::chrono
;
2418 tv
->wallclock
= steady_clock::now ();
2419 run_time_clock::now (tv
->utime
, tv
->stime
);
2423 print_diff_now (struct ui_file
*file
, struct mi_timestamp
*start
)
2425 struct mi_timestamp now
;
2428 print_diff (file
, start
, &now
);
2432 mi_print_timing_maybe (struct ui_file
*file
)
2434 /* If the command is -enable-timing then do_timings may be true
2435 whilst current_command_ts is not initialized. */
2436 if (do_timings
&& current_command_ts
)
2437 print_diff_now (file
, current_command_ts
);
2441 print_diff (struct ui_file
*file
, struct mi_timestamp
*start
,
2442 struct mi_timestamp
*end
)
2444 using namespace std::chrono
;
2446 duration
<double> wallclock
= end
->wallclock
- start
->wallclock
;
2447 duration
<double> utime
= end
->utime
- start
->utime
;
2448 duration
<double> stime
= end
->stime
- start
->stime
;
2452 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
2453 wallclock
.count (), utime
.count (), stime
.count ());
2457 mi_cmd_trace_define_variable (const char *command
, char **argv
, int argc
)
2459 LONGEST initval
= 0;
2460 struct trace_state_variable
*tsv
;
2463 if (argc
!= 1 && argc
!= 2)
2464 error (_("Usage: -trace-define-variable VARIABLE [VALUE]"));
2468 error (_("Name of trace variable should start with '$'"));
2470 validate_trace_state_variable_name (name
);
2472 tsv
= find_trace_state_variable (name
);
2474 tsv
= create_trace_state_variable (name
);
2477 initval
= value_as_long (parse_and_eval (argv
[1]));
2479 tsv
->initial_value
= initval
;
2483 mi_cmd_trace_list_variables (const char *command
, char **argv
, int argc
)
2486 error (_("-trace-list-variables: no arguments allowed"));
2488 tvariables_info_1 ();
2492 mi_cmd_trace_find (const char *command
, char **argv
, int argc
)
2497 error (_("trace selection mode is required"));
2501 if (strcmp (mode
, "none") == 0)
2503 tfind_1 (tfind_number
, -1, 0, 0, 0);
2507 check_trace_running (current_trace_status ());
2509 if (strcmp (mode
, "frame-number") == 0)
2512 error (_("frame number is required"));
2513 tfind_1 (tfind_number
, atoi (argv
[1]), 0, 0, 0);
2515 else if (strcmp (mode
, "tracepoint-number") == 0)
2518 error (_("tracepoint number is required"));
2519 tfind_1 (tfind_tp
, atoi (argv
[1]), 0, 0, 0);
2521 else if (strcmp (mode
, "pc") == 0)
2524 error (_("PC is required"));
2525 tfind_1 (tfind_pc
, 0, parse_and_eval_address (argv
[1]), 0, 0);
2527 else if (strcmp (mode
, "pc-inside-range") == 0)
2530 error (_("Start and end PC are required"));
2531 tfind_1 (tfind_range
, 0, parse_and_eval_address (argv
[1]),
2532 parse_and_eval_address (argv
[2]), 0);
2534 else if (strcmp (mode
, "pc-outside-range") == 0)
2537 error (_("Start and end PC are required"));
2538 tfind_1 (tfind_outside
, 0, parse_and_eval_address (argv
[1]),
2539 parse_and_eval_address (argv
[2]), 0);
2541 else if (strcmp (mode
, "line") == 0)
2543 struct symtabs_and_lines sals
;
2544 struct symtab_and_line sal
;
2545 static CORE_ADDR start_pc
, end_pc
;
2546 struct cleanup
*back_to
;
2549 error (_("Line is required"));
2551 sals
= decode_line_with_current_source (argv
[1],
2552 DECODE_LINE_FUNFIRSTLINE
);
2553 back_to
= make_cleanup (xfree
, sals
.sals
);
2557 if (sal
.symtab
== 0)
2558 error (_("Could not find the specified line"));
2560 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2561 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, 0);
2563 error (_("Could not find the specified line"));
2565 do_cleanups (back_to
);
2568 error (_("Invalid mode '%s'"), mode
);
2570 if (has_stack_frames () || get_traceframe_number () >= 0)
2571 print_stack_frame (get_selected_frame (NULL
), 1, LOC_AND_ADDRESS
, 1);
2575 mi_cmd_trace_save (const char *command
, char **argv
, int argc
)
2577 int target_saves
= 0;
2578 int generate_ctf
= 0;
2585 TARGET_SAVE_OPT
, CTF_OPT
2587 static const struct mi_opt opts
[] =
2589 {"r", TARGET_SAVE_OPT
, 0},
2590 {"ctf", CTF_OPT
, 0},
2596 int opt
= mi_getopt ("-trace-save", argc
, argv
, opts
,
2601 switch ((enum opt
) opt
)
2603 case TARGET_SAVE_OPT
:
2612 if (argc
- oind
!= 1)
2613 error (_("Exactly one argument required "
2614 "(file in which to save trace data)"));
2616 filename
= argv
[oind
];
2619 trace_save_ctf (filename
, target_saves
);
2621 trace_save_tfile (filename
, target_saves
);
2625 mi_cmd_trace_start (const char *command
, char **argv
, int argc
)
2627 start_tracing (NULL
);
2631 mi_cmd_trace_status (const char *command
, char **argv
, int argc
)
2633 trace_status_mi (0);
2637 mi_cmd_trace_stop (const char *command
, char **argv
, int argc
)
2639 stop_tracing (NULL
);
2640 trace_status_mi (1);
2643 /* Implement the "-ada-task-info" command. */
2646 mi_cmd_ada_task_info (const char *command
, char **argv
, int argc
)
2648 if (argc
!= 0 && argc
!= 1)
2649 error (_("Invalid MI command"));
2651 print_ada_task_info (current_uiout
, argv
[0], current_inferior ());
2654 /* Print EXPRESSION according to VALUES. */
2657 print_variable_or_computed (const char *expression
, enum print_values values
)
2661 struct ui_out
*uiout
= current_uiout
;
2665 expression_up expr
= parse_expression (expression
);
2667 if (values
== PRINT_SIMPLE_VALUES
)
2668 val
= evaluate_type (expr
.get ());
2670 val
= evaluate_expression (expr
.get ());
2672 gdb::optional
<ui_out_emit_tuple
> tuple_emitter
;
2673 if (values
!= PRINT_NO_VALUES
)
2674 tuple_emitter
.emplace (uiout
, nullptr);
2675 uiout
->field_string ("name", expression
);
2679 case PRINT_SIMPLE_VALUES
:
2680 type
= check_typedef (value_type (val
));
2681 type_print (value_type (val
), "", &stb
, -1);
2682 uiout
->field_stream ("type", stb
);
2683 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
2684 && TYPE_CODE (type
) != TYPE_CODE_STRUCT
2685 && TYPE_CODE (type
) != TYPE_CODE_UNION
)
2687 struct value_print_options opts
;
2689 get_no_prettyformat_print_options (&opts
);
2691 common_val_print (val
, &stb
, 0, &opts
, current_language
);
2692 uiout
->field_stream ("value", stb
);
2695 case PRINT_ALL_VALUES
:
2697 struct value_print_options opts
;
2699 get_no_prettyformat_print_options (&opts
);
2701 common_val_print (val
, &stb
, 0, &opts
, current_language
);
2702 uiout
->field_stream ("value", stb
);
2708 /* Implement the "-trace-frame-collected" command. */
2711 mi_cmd_trace_frame_collected (const char *command
, char **argv
, int argc
)
2713 struct cleanup
*old_chain
;
2714 struct bp_location
*tloc
;
2716 struct collection_list
*clist
;
2717 struct collection_list tracepoint_list
, stepping_list
;
2718 struct traceframe_info
*tinfo
;
2720 enum print_values var_print_values
= PRINT_ALL_VALUES
;
2721 enum print_values comp_print_values
= PRINT_ALL_VALUES
;
2722 int registers_format
= 'x';
2723 int memory_contents
= 0;
2724 struct ui_out
*uiout
= current_uiout
;
2732 static const struct mi_opt opts
[] =
2734 {"-var-print-values", VAR_PRINT_VALUES
, 1},
2735 {"-comp-print-values", COMP_PRINT_VALUES
, 1},
2736 {"-registers-format", REGISTERS_FORMAT
, 1},
2737 {"-memory-contents", MEMORY_CONTENTS
, 0},
2744 int opt
= mi_getopt ("-trace-frame-collected", argc
, argv
, opts
,
2748 switch ((enum opt
) opt
)
2750 case VAR_PRINT_VALUES
:
2751 var_print_values
= mi_parse_print_values (oarg
);
2753 case COMP_PRINT_VALUES
:
2754 comp_print_values
= mi_parse_print_values (oarg
);
2756 case REGISTERS_FORMAT
:
2757 registers_format
= oarg
[0];
2758 case MEMORY_CONTENTS
:
2759 memory_contents
= 1;
2765 error (_("Usage: -trace-frame-collected "
2766 "[--var-print-values PRINT_VALUES] "
2767 "[--comp-print-values PRINT_VALUES] "
2768 "[--registers-format FORMAT]"
2769 "[--memory-contents]"));
2771 /* This throws an error is not inspecting a trace frame. */
2772 tloc
= get_traceframe_location (&stepping_frame
);
2774 /* This command only makes sense for the current frame, not the
2776 old_chain
= make_cleanup_restore_current_thread ();
2777 select_frame (get_current_frame ());
2779 encode_actions (tloc
, &tracepoint_list
, &stepping_list
);
2782 clist
= &stepping_list
;
2784 clist
= &tracepoint_list
;
2786 tinfo
= get_traceframe_info ();
2788 /* Explicitly wholly collected variables. */
2790 struct cleanup
*list_cleanup
;
2793 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
,
2794 "explicit-variables");
2796 const std::vector
<std::string
> &wholly_collected
2797 = clist
->wholly_collected ();
2798 for (size_t i
= 0; i
< wholly_collected
.size (); i
++)
2800 const std::string
&str
= wholly_collected
[i
];
2801 print_variable_or_computed (str
.c_str (), var_print_values
);
2804 do_cleanups (list_cleanup
);
2807 /* Computed expressions. */
2809 struct cleanup
*list_cleanup
;
2814 = make_cleanup_ui_out_list_begin_end (uiout
,
2815 "computed-expressions");
2817 const std::vector
<std::string
> &computed
= clist
->computed ();
2818 for (size_t i
= 0; i
< computed
.size (); i
++)
2820 const std::string
&str
= computed
[i
];
2821 print_variable_or_computed (str
.c_str (), comp_print_values
);
2824 do_cleanups (list_cleanup
);
2827 /* Registers. Given pseudo-registers, and that some architectures
2828 (like MIPS) actually hide the raw registers, we don't go through
2829 the trace frame info, but instead consult the register cache for
2830 register availability. */
2832 struct cleanup
*list_cleanup
;
2833 struct frame_info
*frame
;
2834 struct gdbarch
*gdbarch
;
2838 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "registers");
2840 frame
= get_selected_frame (NULL
);
2841 gdbarch
= get_frame_arch (frame
);
2842 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
2844 for (regnum
= 0; regnum
< numregs
; regnum
++)
2846 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
2847 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
2850 output_register (frame
, regnum
, registers_format
, 1);
2853 do_cleanups (list_cleanup
);
2856 /* Trace state variables. */
2858 struct cleanup
*list_cleanup
;
2863 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "tvars");
2866 make_cleanup (free_current_contents
, &tsvname
);
2868 for (i
= 0; VEC_iterate (int, tinfo
->tvars
, i
, tvar
); i
++)
2870 struct trace_state_variable
*tsv
;
2872 tsv
= find_trace_state_variable_by_number (tvar
);
2874 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
2878 tsvname
= (char *) xrealloc (tsvname
, strlen (tsv
->name
) + 2);
2880 strcpy (tsvname
+ 1, tsv
->name
);
2881 uiout
->field_string ("name", tsvname
);
2883 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
2885 uiout
->field_int ("current", tsv
->value
);
2889 uiout
->field_skip ("name");
2890 uiout
->field_skip ("current");
2894 do_cleanups (list_cleanup
);
2899 struct cleanup
*list_cleanup
;
2900 VEC(mem_range_s
) *available_memory
= NULL
;
2901 struct mem_range
*r
;
2904 traceframe_available_memory (&available_memory
, 0, ULONGEST_MAX
);
2905 make_cleanup (VEC_cleanup(mem_range_s
), &available_memory
);
2907 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "memory");
2909 for (i
= 0; VEC_iterate (mem_range_s
, available_memory
, i
, r
); i
++)
2911 struct cleanup
*cleanup_child
;
2913 struct gdbarch
*gdbarch
= target_gdbarch ();
2915 cleanup_child
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2917 uiout
->field_core_addr ("address", gdbarch
, r
->start
);
2918 uiout
->field_int ("length", r
->length
);
2920 data
= (gdb_byte
*) xmalloc (r
->length
);
2921 make_cleanup (xfree
, data
);
2923 if (memory_contents
)
2925 if (target_read_memory (r
->start
, data
, r
->length
) == 0)
2930 data_str
= (char *) xmalloc (r
->length
* 2 + 1);
2931 make_cleanup (xfree
, data_str
);
2933 for (m
= 0, p
= data_str
; m
< r
->length
; ++m
, p
+= 2)
2934 sprintf (p
, "%02x", data
[m
]);
2935 uiout
->field_string ("contents", data_str
);
2938 uiout
->field_skip ("contents");
2940 do_cleanups (cleanup_child
);
2943 do_cleanups (list_cleanup
);
2946 do_cleanups (old_chain
);
2950 _initialize_mi_main (void)
2952 struct cmd_list_element
*c
;
2954 add_setshow_boolean_cmd ("mi-async", class_run
,
2956 Set whether MI asynchronous mode is enabled."), _("\
2957 Show whether MI asynchronous mode is enabled."), _("\
2958 Tells GDB whether MI should be in asynchronous mode."),
2959 set_mi_async_command
,
2960 show_mi_async_command
,
2964 /* Alias old "target-async" to "mi-async". */
2965 c
= add_alias_cmd ("target-async", "mi-async", class_run
, 0, &setlist
);
2966 deprecate_cmd (c
, "set mi-async");
2967 c
= add_alias_cmd ("target-async", "mi-async", class_run
, 0, &showlist
);
2968 deprecate_cmd (c
, "show mi-async");