3 Copyright (C) 2000-2014 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"
27 #include "exceptions.h"
29 #include "gdbthread.h"
32 #include "mi-getopt.h"
33 #include "mi-console.h"
37 #include "event-loop.h"
38 #include "event-top.h"
39 #include "gdbcore.h" /* For write_memory(). */
45 #include "mi-common.h"
50 #include "splay-tree.h"
51 #include "tracepoint.h"
55 #include "extension.h"
61 #if defined HAVE_SYS_RESOURCE_H
62 #include <sys/resource.h>
76 struct ui_file
*raw_stdout
;
78 /* This is used to pass the current command timestamp down to
79 continuation routines. */
80 static struct mi_timestamp
*current_command_ts
;
82 static int do_timings
= 0;
85 /* Few commands would like to know if options like --thread-group were
86 explicitly specified. This variable keeps the current parsed
87 command including all option, and make it possible. */
88 static struct mi_parse
*current_context
;
90 int running_result_record_printed
= 1;
92 /* Flag indicating that the target has proceeded since the last
93 command was issued. */
96 extern void _initialize_mi_main (void);
97 static void mi_cmd_execute (struct mi_parse
*parse
);
99 static void mi_execute_cli_command (const char *cmd
, int args_p
,
101 static void mi_execute_async_cli_command (char *cli_command
,
102 char **argv
, int argc
);
103 static int register_changed_p (int regnum
, struct regcache
*,
105 static void output_register (struct frame_info
*, int regnum
, int format
,
106 int skip_unavailable
);
108 /* Controls whether the frontend wants MI in async mode. */
109 static int mi_async
= 0;
111 /* The set command writes to this variable. If the inferior is
112 executing, mi_async is *not* updated. */
113 static int mi_async_1
= 0;
116 set_mi_async_command (char *args
, int from_tty
,
117 struct cmd_list_element
*c
)
119 if (have_live_inferiors ())
121 mi_async_1
= mi_async
;
122 error (_("Cannot change this setting while the inferior is running."));
125 mi_async
= mi_async_1
;
129 show_mi_async_command (struct ui_file
*file
, int from_tty
,
130 struct cmd_list_element
*c
,
133 fprintf_filtered (file
,
134 _("Whether MI is in asynchronous mode is %s.\n"),
138 /* A wrapper for target_can_async_p that takes the MI setting into
144 return mi_async
&& target_can_async_p ();
147 /* Command implementations. FIXME: Is this libgdb? No. This is the MI
148 layer that calls libgdb. Any operation used in the below should be
151 static void timestamp (struct mi_timestamp
*tv
);
153 static void print_diff_now (struct mi_timestamp
*start
);
154 static void print_diff (struct mi_timestamp
*start
, struct mi_timestamp
*end
);
157 mi_cmd_gdb_exit (char *command
, char **argv
, int argc
)
159 /* We have to print everything right here because we never return. */
161 fputs_unfiltered (current_token
, raw_stdout
);
162 fputs_unfiltered ("^exit\n", raw_stdout
);
163 mi_out_put (current_uiout
, raw_stdout
);
164 gdb_flush (raw_stdout
);
165 /* FIXME: The function called is not yet a formal libgdb function. */
166 quit_force (NULL
, FROM_TTY
);
170 mi_cmd_exec_next (char *command
, char **argv
, int argc
)
172 /* FIXME: Should call a libgdb function, not a cli wrapper. */
173 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
174 mi_execute_async_cli_command ("reverse-next", argv
+ 1, argc
- 1);
176 mi_execute_async_cli_command ("next", argv
, argc
);
180 mi_cmd_exec_next_instruction (char *command
, char **argv
, int argc
)
182 /* FIXME: Should call a libgdb function, not a cli wrapper. */
183 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
184 mi_execute_async_cli_command ("reverse-nexti", argv
+ 1, argc
- 1);
186 mi_execute_async_cli_command ("nexti", argv
, argc
);
190 mi_cmd_exec_step (char *command
, char **argv
, int argc
)
192 /* FIXME: Should call a libgdb function, not a cli wrapper. */
193 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
194 mi_execute_async_cli_command ("reverse-step", argv
+ 1, argc
- 1);
196 mi_execute_async_cli_command ("step", argv
, argc
);
200 mi_cmd_exec_step_instruction (char *command
, char **argv
, int argc
)
202 /* FIXME: Should call a libgdb function, not a cli wrapper. */
203 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
204 mi_execute_async_cli_command ("reverse-stepi", argv
+ 1, argc
- 1);
206 mi_execute_async_cli_command ("stepi", argv
, argc
);
210 mi_cmd_exec_finish (char *command
, char **argv
, int argc
)
212 /* FIXME: Should call a libgdb function, not a cli wrapper. */
213 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
214 mi_execute_async_cli_command ("reverse-finish", argv
+ 1, argc
- 1);
216 mi_execute_async_cli_command ("finish", argv
, argc
);
220 mi_cmd_exec_return (char *command
, char **argv
, int argc
)
222 /* This command doesn't really execute the target, it just pops the
223 specified number of frames. */
225 /* Call return_command with from_tty argument equal to 0 so as to
226 avoid being queried. */
227 return_command (*argv
, 0);
229 /* Call return_command with from_tty argument equal to 0 so as to
230 avoid being queried. */
231 return_command (NULL
, 0);
233 /* Because we have called return_command with from_tty = 0, we need
234 to print the frame here. */
235 print_stack_frame (get_selected_frame (NULL
), 1, LOC_AND_ADDRESS
, 1);
239 mi_cmd_exec_jump (char *args
, char **argv
, int argc
)
241 /* FIXME: Should call a libgdb function, not a cli wrapper. */
242 mi_execute_async_cli_command ("jump", argv
, argc
);
246 proceed_thread (struct thread_info
*thread
, int pid
)
248 if (!is_stopped (thread
->ptid
))
251 if (pid
!= 0 && ptid_get_pid (thread
->ptid
) != pid
)
254 switch_to_thread (thread
->ptid
);
255 clear_proceed_status (0);
256 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
, 0);
260 proceed_thread_callback (struct thread_info
*thread
, void *arg
)
262 int pid
= *(int *)arg
;
264 proceed_thread (thread
, pid
);
269 exec_continue (char **argv
, int argc
)
271 prepare_execution_command (¤t_target
, mi_async_p ());
275 /* In non-stop mode, 'resume' always resumes a single thread.
276 Therefore, to resume all threads of the current inferior, or
277 all threads in all inferiors, we need to iterate over
280 See comment on infcmd.c:proceed_thread_callback for rationale. */
281 if (current_context
->all
|| current_context
->thread_group
!= -1)
284 struct cleanup
*back_to
= make_cleanup_restore_current_thread ();
286 if (!current_context
->all
)
289 = find_inferior_id (current_context
->thread_group
);
293 iterate_over_threads (proceed_thread_callback
, &pid
);
294 do_cleanups (back_to
);
303 struct cleanup
*back_to
= make_cleanup_restore_integer (&sched_multi
);
305 if (current_context
->all
)
312 /* In all-stop mode, -exec-continue traditionally resumed
313 either all threads, or one thread, depending on the
314 'scheduler-locking' variable. Let's continue to do the
318 do_cleanups (back_to
);
323 exec_direction_forward (void *notused
)
325 execution_direction
= EXEC_FORWARD
;
329 exec_reverse_continue (char **argv
, int argc
)
331 enum exec_direction_kind dir
= execution_direction
;
332 struct cleanup
*old_chain
;
334 if (dir
== EXEC_REVERSE
)
335 error (_("Already in reverse mode."));
337 if (!target_can_execute_reverse
)
338 error (_("Target %s does not support this command."), target_shortname
);
340 old_chain
= make_cleanup (exec_direction_forward
, NULL
);
341 execution_direction
= EXEC_REVERSE
;
342 exec_continue (argv
, argc
);
343 do_cleanups (old_chain
);
347 mi_cmd_exec_continue (char *command
, char **argv
, int argc
)
349 if (argc
> 0 && strcmp (argv
[0], "--reverse") == 0)
350 exec_reverse_continue (argv
+ 1, argc
- 1);
352 exec_continue (argv
, argc
);
356 interrupt_thread_callback (struct thread_info
*thread
, void *arg
)
358 int pid
= *(int *)arg
;
360 if (!is_running (thread
->ptid
))
363 if (ptid_get_pid (thread
->ptid
) != pid
)
366 target_stop (thread
->ptid
);
370 /* Interrupt the execution of the target. Note how we must play
371 around with the token variables, in order to display the current
372 token in the result of the interrupt command, and the previous
373 execution token when the target finally stops. See comments in
377 mi_cmd_exec_interrupt (char *command
, char **argv
, int argc
)
379 /* In all-stop mode, everything stops, so we don't need to try
380 anything specific. */
383 interrupt_target_1 (0);
387 if (current_context
->all
)
389 /* This will interrupt all threads in all inferiors. */
390 interrupt_target_1 (1);
392 else if (current_context
->thread_group
!= -1)
394 struct inferior
*inf
= find_inferior_id (current_context
->thread_group
);
396 iterate_over_threads (interrupt_thread_callback
, &inf
->pid
);
400 /* Interrupt just the current thread -- either explicitly
401 specified via --thread or whatever was current before
402 MI command was sent. */
403 interrupt_target_1 (0);
407 /* Callback for iterate_over_inferiors which starts the execution
408 of the given inferior.
410 ARG is a pointer to an integer whose value, if non-zero, indicates
411 that the program should be stopped when reaching the main subprogram
412 (similar to what the CLI "start" command does). */
415 run_one_inferior (struct inferior
*inf
, void *arg
)
417 int start_p
= *(int *) arg
;
418 const char *run_cmd
= start_p
? "start" : "run";
422 if (inf
->pid
!= ptid_get_pid (inferior_ptid
))
424 struct thread_info
*tp
;
426 tp
= any_thread_of_process (inf
->pid
);
428 error (_("Inferior has no threads."));
430 switch_to_thread (tp
->ptid
);
435 set_current_inferior (inf
);
436 switch_to_thread (null_ptid
);
437 set_current_program_space (inf
->pspace
);
439 mi_execute_cli_command (run_cmd
, mi_async_p (),
440 mi_async_p () ? "&" : NULL
);
445 mi_cmd_exec_run (char *command
, char **argv
, int argc
)
450 /* Parse the command options. */
455 static const struct mi_opt opts
[] =
457 {"-start", START_OPT
, 0},
466 int opt
= mi_getopt ("-exec-run", argc
, argv
, opts
, &oind
, &oarg
);
470 switch ((enum opt
) opt
)
478 /* This command does not accept any argument. Make sure the user
479 did not provide any. */
481 error (_("Invalid argument: %s"), argv
[oind
]);
483 if (current_context
->all
)
485 struct cleanup
*back_to
= save_current_space_and_thread ();
487 iterate_over_inferiors (run_one_inferior
, &start_p
);
488 do_cleanups (back_to
);
492 const char *run_cmd
= start_p
? "start" : "run";
494 mi_execute_cli_command (run_cmd
, mi_async_p (),
495 mi_async_p () ? "&" : NULL
);
501 find_thread_of_process (struct thread_info
*ti
, void *p
)
505 if (ptid_get_pid (ti
->ptid
) == pid
&& !is_exited (ti
->ptid
))
512 mi_cmd_target_detach (char *command
, char **argv
, int argc
)
514 if (argc
!= 0 && argc
!= 1)
515 error (_("Usage: -target-detach [pid | thread-group]"));
519 struct thread_info
*tp
;
523 /* First see if we are dealing with a thread-group id. */
526 struct inferior
*inf
;
527 int id
= strtoul (argv
[0] + 1, &end
, 0);
530 error (_("Invalid syntax of thread-group id '%s'"), argv
[0]);
532 inf
= find_inferior_id (id
);
534 error (_("Non-existent thread-group id '%d'"), id
);
540 /* We must be dealing with a pid. */
541 pid
= strtol (argv
[0], &end
, 10);
544 error (_("Invalid identifier '%s'"), argv
[0]);
547 /* Pick any thread in the desired process. Current
548 target_detach detaches from the parent of inferior_ptid. */
549 tp
= iterate_over_threads (find_thread_of_process
, &pid
);
551 error (_("Thread group is empty"));
553 switch_to_thread (tp
->ptid
);
556 detach_command (NULL
, 0);
560 mi_cmd_thread_select (char *command
, char **argv
, int argc
)
563 char *mi_error_message
;
566 error (_("-thread-select: USAGE: threadnum."));
568 rc
= gdb_thread_select (current_uiout
, argv
[0], &mi_error_message
);
570 if (rc
== GDB_RC_FAIL
)
572 make_cleanup (xfree
, mi_error_message
);
573 error ("%s", mi_error_message
);
578 mi_cmd_thread_list_ids (char *command
, char **argv
, int argc
)
581 char *mi_error_message
;
584 error (_("-thread-list-ids: No arguments required."));
586 rc
= gdb_list_thread_ids (current_uiout
, &mi_error_message
);
588 if (rc
== GDB_RC_FAIL
)
590 make_cleanup (xfree
, mi_error_message
);
591 error ("%s", mi_error_message
);
596 mi_cmd_thread_info (char *command
, char **argv
, int argc
)
598 if (argc
!= 0 && argc
!= 1)
599 error (_("Invalid MI command"));
601 print_thread_info (current_uiout
, argv
[0], -1);
604 struct collect_cores_data
612 collect_cores (struct thread_info
*ti
, void *xdata
)
614 struct collect_cores_data
*data
= xdata
;
616 if (ptid_get_pid (ti
->ptid
) == data
->pid
)
618 int core
= target_core_of_thread (ti
->ptid
);
621 VEC_safe_push (int, data
->cores
, core
);
628 unique (int *b
, int *e
)
638 struct print_one_inferior_data
641 VEC (int) *inferiors
;
645 print_one_inferior (struct inferior
*inferior
, void *xdata
)
647 struct print_one_inferior_data
*top_data
= xdata
;
648 struct ui_out
*uiout
= current_uiout
;
650 if (VEC_empty (int, top_data
->inferiors
)
651 || bsearch (&(inferior
->pid
), VEC_address (int, top_data
->inferiors
),
652 VEC_length (int, top_data
->inferiors
), sizeof (int),
653 compare_positive_ints
))
655 struct collect_cores_data data
;
656 struct cleanup
*back_to
657 = make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
659 ui_out_field_fmt (uiout
, "id", "i%d", inferior
->num
);
660 ui_out_field_string (uiout
, "type", "process");
661 if (inferior
->has_exit_code
)
662 ui_out_field_string (uiout
, "exit-code",
663 int_string (inferior
->exit_code
, 8, 0, 0, 1));
664 if (inferior
->pid
!= 0)
665 ui_out_field_int (uiout
, "pid", inferior
->pid
);
667 if (inferior
->pspace
->pspace_exec_filename
!= NULL
)
669 ui_out_field_string (uiout
, "executable",
670 inferior
->pspace
->pspace_exec_filename
);
674 if (inferior
->pid
!= 0)
676 data
.pid
= inferior
->pid
;
677 iterate_over_threads (collect_cores
, &data
);
680 if (!VEC_empty (int, data
.cores
))
683 struct cleanup
*back_to_2
=
684 make_cleanup_ui_out_list_begin_end (uiout
, "cores");
686 qsort (VEC_address (int, data
.cores
),
687 VEC_length (int, data
.cores
), sizeof (int),
688 compare_positive_ints
);
690 b
= VEC_address (int, data
.cores
);
691 e
= b
+ VEC_length (int, data
.cores
);
695 ui_out_field_int (uiout
, NULL
, *b
);
697 do_cleanups (back_to_2
);
700 if (top_data
->recurse
)
701 print_thread_info (uiout
, NULL
, inferior
->pid
);
703 do_cleanups (back_to
);
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 ui_out_field_string (uiout
, NULL
, p
);
726 do_cleanups (back_to
);
730 free_vector_of_ints (void *xvector
)
732 VEC (int) **vector
= 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
)
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 struct cleanup
*back_to
;
829 const char *pid
= get_osdata_column (item
, "pid");
830 const char *cmd
= get_osdata_column (item
, "command");
831 const char *user
= get_osdata_column (item
, "user");
832 const char *cores
= get_osdata_column (item
, "cores");
834 int pid_i
= strtoul (pid
, NULL
, 0);
836 /* At present, the target will return all available processes
837 and if information about specific ones was required, we filter
838 undesired processes here. */
839 if (ids
&& bsearch (&pid_i
, VEC_address (int, ids
),
840 VEC_length (int, ids
),
841 sizeof (int), compare_positive_ints
) == NULL
)
845 back_to
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
847 ui_out_field_fmt (uiout
, "id", "%s", pid
);
848 ui_out_field_string (uiout
, "type", "process");
850 ui_out_field_string (uiout
, "description", cmd
);
852 ui_out_field_string (uiout
, "user", user
);
854 output_cores (uiout
, "cores", cores
);
858 splay_tree_node n
= splay_tree_lookup (tree
, pid_i
);
861 VEC (osdata_item_s
) *children
= (VEC (osdata_item_s
) *) n
->value
;
862 struct osdata_item
*child
;
865 make_cleanup_ui_out_list_begin_end (uiout
, "threads");
868 VEC_iterate (osdata_item_s
, children
, ix_child
, child
);
871 struct cleanup
*back_to_2
=
872 make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
873 const char *tid
= get_osdata_column (child
, "tid");
874 const char *tcore
= get_osdata_column (child
, "core");
876 ui_out_field_string (uiout
, "id", tid
);
878 ui_out_field_string (uiout
, "core", tcore
);
880 do_cleanups (back_to_2
);
885 do_cleanups (back_to
);
888 do_cleanups (cleanup
);
892 mi_cmd_list_thread_groups (char *command
, char **argv
, int argc
)
894 struct ui_out
*uiout
= current_uiout
;
895 struct cleanup
*back_to
;
902 AVAILABLE_OPT
, RECURSE_OPT
904 static const struct mi_opt opts
[] =
906 {"-available", AVAILABLE_OPT
, 0},
907 {"-recurse", RECURSE_OPT
, 1},
916 int opt
= mi_getopt ("-list-thread-groups", argc
, argv
, opts
,
921 switch ((enum opt
) opt
)
927 if (strcmp (oarg
, "0") == 0)
929 else if (strcmp (oarg
, "1") == 0)
932 error (_("only '0' and '1' are valid values "
933 "for the '--recurse' option"));
938 for (; oind
< argc
; ++oind
)
943 if (*(argv
[oind
]) != 'i')
944 error (_("invalid syntax of group id '%s'"), argv
[oind
]);
946 inf
= strtoul (argv
[oind
] + 1, &end
, 0);
949 error (_("invalid syntax of group id '%s'"), argv
[oind
]);
950 VEC_safe_push (int, ids
, inf
);
952 if (VEC_length (int, ids
) > 1)
953 qsort (VEC_address (int, ids
),
954 VEC_length (int, ids
),
955 sizeof (int), compare_positive_ints
);
957 back_to
= make_cleanup (free_vector_of_ints
, &ids
);
961 list_available_thread_groups (ids
, recurse
);
963 else if (VEC_length (int, ids
) == 1)
965 /* Local thread groups, single id. */
966 int id
= *VEC_address (int, ids
);
967 struct inferior
*inf
= find_inferior_id (id
);
970 error (_("Non-existent thread group id '%d'"), id
);
972 print_thread_info (uiout
, NULL
, inf
->pid
);
976 struct print_one_inferior_data data
;
978 data
.recurse
= recurse
;
979 data
.inferiors
= ids
;
981 /* Local thread groups. Either no explicit ids -- and we
982 print everything, or several explicit ids. In both cases,
983 we print more than one group, and have to use 'groups'
984 as the top-level element. */
985 make_cleanup_ui_out_list_begin_end (uiout
, "groups");
986 update_thread_list ();
987 iterate_over_inferiors (print_one_inferior
, &data
);
990 do_cleanups (back_to
);
994 mi_cmd_data_list_register_names (char *command
, char **argv
, int argc
)
996 struct gdbarch
*gdbarch
;
997 struct ui_out
*uiout
= current_uiout
;
1000 struct cleanup
*cleanup
;
1002 /* Note that the test for a valid register must include checking the
1003 gdbarch_register_name because gdbarch_num_regs may be allocated
1004 for the union of the register sets within a family of related
1005 processors. In this case, some entries of gdbarch_register_name
1006 will change depending upon the particular processor being
1009 gdbarch
= get_current_arch ();
1010 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1012 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "register-names");
1014 if (argc
== 0) /* No args, just do all the regs. */
1020 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1021 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1022 ui_out_field_string (uiout
, NULL
, "");
1024 ui_out_field_string (uiout
, NULL
,
1025 gdbarch_register_name (gdbarch
, regnum
));
1029 /* Else, list of register #s, just do listed regs. */
1030 for (i
= 0; i
< argc
; i
++)
1032 regnum
= atoi (argv
[i
]);
1033 if (regnum
< 0 || regnum
>= numregs
)
1034 error (_("bad register number"));
1036 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1037 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1038 ui_out_field_string (uiout
, NULL
, "");
1040 ui_out_field_string (uiout
, NULL
,
1041 gdbarch_register_name (gdbarch
, regnum
));
1043 do_cleanups (cleanup
);
1047 mi_cmd_data_list_changed_registers (char *command
, char **argv
, int argc
)
1049 static struct regcache
*this_regs
= NULL
;
1050 struct ui_out
*uiout
= current_uiout
;
1051 struct regcache
*prev_regs
;
1052 struct gdbarch
*gdbarch
;
1053 int regnum
, numregs
, changed
;
1055 struct cleanup
*cleanup
;
1057 /* The last time we visited this function, the current frame's
1058 register contents were saved in THIS_REGS. Move THIS_REGS over
1059 to PREV_REGS, and refresh THIS_REGS with the now-current register
1062 prev_regs
= this_regs
;
1063 this_regs
= frame_save_as_regcache (get_selected_frame (NULL
));
1064 cleanup
= make_cleanup_regcache_xfree (prev_regs
);
1066 /* Note that the test for a valid register must include checking the
1067 gdbarch_register_name because gdbarch_num_regs may be allocated
1068 for the union of the register sets within a family of related
1069 processors. In this case, some entries of gdbarch_register_name
1070 will change depending upon the particular processor being
1073 gdbarch
= get_regcache_arch (this_regs
);
1074 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1076 make_cleanup_ui_out_list_begin_end (uiout
, "changed-registers");
1080 /* No args, just do all the regs. */
1085 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1086 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1088 changed
= register_changed_p (regnum
, prev_regs
, this_regs
);
1090 error (_("-data-list-changed-registers: "
1091 "Unable to read register contents."));
1093 ui_out_field_int (uiout
, NULL
, regnum
);
1097 /* Else, list of register #s, just do listed regs. */
1098 for (i
= 0; i
< argc
; i
++)
1100 regnum
= atoi (argv
[i
]);
1104 && gdbarch_register_name (gdbarch
, regnum
) != NULL
1105 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
1107 changed
= register_changed_p (regnum
, prev_regs
, this_regs
);
1109 error (_("-data-list-changed-registers: "
1110 "Unable to read register contents."));
1112 ui_out_field_int (uiout
, NULL
, regnum
);
1115 error (_("bad register number"));
1117 do_cleanups (cleanup
);
1121 register_changed_p (int regnum
, struct regcache
*prev_regs
,
1122 struct regcache
*this_regs
)
1124 struct gdbarch
*gdbarch
= get_regcache_arch (this_regs
);
1125 gdb_byte prev_buffer
[MAX_REGISTER_SIZE
];
1126 gdb_byte this_buffer
[MAX_REGISTER_SIZE
];
1127 enum register_status prev_status
;
1128 enum register_status this_status
;
1130 /* First time through or after gdbarch change consider all registers
1132 if (!prev_regs
|| get_regcache_arch (prev_regs
) != gdbarch
)
1135 /* Get register contents and compare. */
1136 prev_status
= regcache_cooked_read (prev_regs
, regnum
, prev_buffer
);
1137 this_status
= regcache_cooked_read (this_regs
, regnum
, this_buffer
);
1139 if (this_status
!= prev_status
)
1141 else if (this_status
== REG_VALID
)
1142 return memcmp (prev_buffer
, this_buffer
,
1143 register_size (gdbarch
, regnum
)) != 0;
1148 /* Return a list of register number and value pairs. The valid
1149 arguments expected are: a letter indicating the format in which to
1150 display the registers contents. This can be one of: x
1151 (hexadecimal), d (decimal), N (natural), t (binary), o (octal), r
1152 (raw). After the format argument there can be a sequence of
1153 numbers, indicating which registers to fetch the content of. If
1154 the format is the only argument, a list of all the registers with
1155 their values is returned. */
1158 mi_cmd_data_list_register_values (char *command
, char **argv
, int argc
)
1160 struct ui_out
*uiout
= current_uiout
;
1161 struct frame_info
*frame
;
1162 struct gdbarch
*gdbarch
;
1163 int regnum
, numregs
, format
;
1165 struct cleanup
*list_cleanup
;
1166 int skip_unavailable
= 0;
1172 static const struct mi_opt opts
[] =
1174 {"-skip-unavailable", SKIP_UNAVAILABLE
, 0},
1178 /* Note that the test for a valid register must include checking the
1179 gdbarch_register_name because gdbarch_num_regs may be allocated
1180 for the union of the register sets within a family of related
1181 processors. In this case, some entries of gdbarch_register_name
1182 will change depending upon the particular processor being
1188 int opt
= mi_getopt ("-data-list-register-values", argc
, argv
,
1189 opts
, &oind
, &oarg
);
1193 switch ((enum opt
) opt
)
1195 case SKIP_UNAVAILABLE
:
1196 skip_unavailable
= 1;
1201 if (argc
- oind
< 1)
1202 error (_("-data-list-register-values: Usage: "
1203 "-data-list-register-values [--skip-unavailable] <format>"
1204 " [<regnum1>...<regnumN>]"));
1206 format
= (int) argv
[oind
][0];
1208 frame
= get_selected_frame (NULL
);
1209 gdbarch
= get_frame_arch (frame
);
1210 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1212 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "register-values");
1214 if (argc
- oind
== 1)
1216 /* No args, beside the format: do all the regs. */
1221 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1222 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1225 output_register (frame
, regnum
, format
, skip_unavailable
);
1229 /* Else, list of register #s, just do listed regs. */
1230 for (i
= 1 + oind
; i
< argc
; i
++)
1232 regnum
= atoi (argv
[i
]);
1236 && gdbarch_register_name (gdbarch
, regnum
) != NULL
1237 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
1238 output_register (frame
, regnum
, format
, skip_unavailable
);
1240 error (_("bad register number"));
1242 do_cleanups (list_cleanup
);
1245 /* Output one register REGNUM's contents in the desired FORMAT. If
1246 SKIP_UNAVAILABLE is true, skip the register if it is
1250 output_register (struct frame_info
*frame
, int regnum
, int format
,
1251 int skip_unavailable
)
1253 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1254 struct ui_out
*uiout
= current_uiout
;
1255 struct value
*val
= value_of_register (regnum
, frame
);
1256 struct cleanup
*tuple_cleanup
;
1257 struct value_print_options opts
;
1258 struct ui_file
*stb
;
1260 if (skip_unavailable
&& !value_entirely_available (val
))
1263 tuple_cleanup
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1264 ui_out_field_int (uiout
, "number", regnum
);
1272 stb
= mem_fileopen ();
1273 make_cleanup_ui_file_delete (stb
);
1275 get_formatted_print_options (&opts
, format
);
1277 val_print (value_type (val
),
1278 value_contents_for_printing (val
),
1279 value_embedded_offset (val
), 0,
1280 stb
, 0, val
, &opts
, current_language
);
1281 ui_out_field_stream (uiout
, "value", stb
);
1283 do_cleanups (tuple_cleanup
);
1286 /* Write given values into registers. The registers and values are
1287 given as pairs. The corresponding MI command is
1288 -data-write-register-values <format>
1289 [<regnum1> <value1>...<regnumN> <valueN>] */
1291 mi_cmd_data_write_register_values (char *command
, char **argv
, int argc
)
1293 struct regcache
*regcache
;
1294 struct gdbarch
*gdbarch
;
1297 /* Note that the test for a valid register must include checking the
1298 gdbarch_register_name because gdbarch_num_regs may be allocated
1299 for the union of the register sets within a family of related
1300 processors. In this case, some entries of gdbarch_register_name
1301 will change depending upon the particular processor being
1304 regcache
= get_current_regcache ();
1305 gdbarch
= get_regcache_arch (regcache
);
1306 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1309 error (_("-data-write-register-values: Usage: -data-write-register-"
1310 "values <format> [<regnum1> <value1>...<regnumN> <valueN>]"));
1312 if (!target_has_registers
)
1313 error (_("-data-write-register-values: No registers."));
1316 error (_("-data-write-register-values: No regs and values specified."));
1319 error (_("-data-write-register-values: "
1320 "Regs and vals are not in pairs."));
1322 for (i
= 1; i
< argc
; i
= i
+ 2)
1324 int regnum
= atoi (argv
[i
]);
1326 if (regnum
>= 0 && regnum
< numregs
1327 && gdbarch_register_name (gdbarch
, regnum
)
1328 && *gdbarch_register_name (gdbarch
, regnum
))
1332 /* Get the value as a number. */
1333 value
= parse_and_eval_address (argv
[i
+ 1]);
1335 /* Write it down. */
1336 regcache_cooked_write_signed (regcache
, regnum
, value
);
1339 error (_("bad register number"));
1343 /* Evaluate the value of the argument. The argument is an
1344 expression. If the expression contains spaces it needs to be
1345 included in double quotes. */
1348 mi_cmd_data_evaluate_expression (char *command
, char **argv
, int argc
)
1350 struct expression
*expr
;
1351 struct cleanup
*old_chain
;
1353 struct ui_file
*stb
;
1354 struct value_print_options opts
;
1355 struct ui_out
*uiout
= current_uiout
;
1357 stb
= mem_fileopen ();
1358 old_chain
= make_cleanup_ui_file_delete (stb
);
1361 error (_("-data-evaluate-expression: "
1362 "Usage: -data-evaluate-expression expression"));
1364 expr
= parse_expression (argv
[0]);
1366 make_cleanup (free_current_contents
, &expr
);
1368 val
= evaluate_expression (expr
);
1370 /* Print the result of the expression evaluation. */
1371 get_user_print_options (&opts
);
1373 common_val_print (val
, stb
, 0, &opts
, current_language
);
1375 ui_out_field_stream (uiout
, "value", stb
);
1377 do_cleanups (old_chain
);
1380 /* This is the -data-read-memory command.
1382 ADDR: start address of data to be dumped.
1383 WORD-FORMAT: a char indicating format for the ``word''. See
1385 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
1386 NR_ROW: Number of rows.
1387 NR_COL: The number of colums (words per row).
1388 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
1389 ASCHAR for unprintable characters.
1391 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
1392 displayes them. Returns:
1394 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
1397 The number of bytes read is SIZE*ROW*COL. */
1400 mi_cmd_data_read_memory (char *command
, char **argv
, int argc
)
1402 struct gdbarch
*gdbarch
= get_current_arch ();
1403 struct ui_out
*uiout
= current_uiout
;
1404 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
1406 long total_bytes
, nr_cols
, nr_rows
;
1408 struct type
*word_type
;
1421 static const struct mi_opt opts
[] =
1423 {"o", OFFSET_OPT
, 1},
1429 int opt
= mi_getopt ("-data-read-memory", argc
, argv
, opts
,
1434 switch ((enum opt
) opt
)
1437 offset
= atol (oarg
);
1444 if (argc
< 5 || argc
> 6)
1445 error (_("-data-read-memory: Usage: "
1446 "ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR]."));
1448 /* Extract all the arguments. */
1450 /* Start address of the memory dump. */
1451 addr
= parse_and_eval_address (argv
[0]) + offset
;
1452 /* The format character to use when displaying a memory word. See
1453 the ``x'' command. */
1454 word_format
= argv
[1][0];
1455 /* The size of the memory word. */
1456 word_size
= atol (argv
[2]);
1460 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1464 word_type
= builtin_type (gdbarch
)->builtin_int16
;
1468 word_type
= builtin_type (gdbarch
)->builtin_int32
;
1472 word_type
= builtin_type (gdbarch
)->builtin_int64
;
1476 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1479 /* The number of rows. */
1480 nr_rows
= atol (argv
[3]);
1482 error (_("-data-read-memory: invalid number of rows."));
1484 /* Number of bytes per row. */
1485 nr_cols
= atol (argv
[4]);
1487 error (_("-data-read-memory: invalid number of columns."));
1489 /* The un-printable character when printing ascii. */
1495 /* Create a buffer and read it in. */
1496 total_bytes
= word_size
* nr_rows
* nr_cols
;
1497 mbuf
= xcalloc (total_bytes
, 1);
1498 make_cleanup (xfree
, mbuf
);
1500 /* Dispatch memory reads to the topmost target, not the flattened
1502 nr_bytes
= target_read (current_target
.beneath
,
1503 TARGET_OBJECT_MEMORY
, NULL
, mbuf
,
1506 error (_("Unable to read memory."));
1508 /* Output the header information. */
1509 ui_out_field_core_addr (uiout
, "addr", gdbarch
, addr
);
1510 ui_out_field_int (uiout
, "nr-bytes", nr_bytes
);
1511 ui_out_field_int (uiout
, "total-bytes", total_bytes
);
1512 ui_out_field_core_addr (uiout
, "next-row",
1513 gdbarch
, addr
+ word_size
* nr_cols
);
1514 ui_out_field_core_addr (uiout
, "prev-row",
1515 gdbarch
, addr
- word_size
* nr_cols
);
1516 ui_out_field_core_addr (uiout
, "next-page", gdbarch
, addr
+ total_bytes
);
1517 ui_out_field_core_addr (uiout
, "prev-page", gdbarch
, addr
- total_bytes
);
1519 /* Build the result as a two dimentional table. */
1521 struct ui_file
*stream
;
1522 struct cleanup
*cleanup_stream
;
1526 stream
= mem_fileopen ();
1527 cleanup_stream
= make_cleanup_ui_file_delete (stream
);
1529 make_cleanup_ui_out_list_begin_end (uiout
, "memory");
1530 for (row
= 0, row_byte
= 0;
1532 row
++, row_byte
+= nr_cols
* word_size
)
1536 struct cleanup
*cleanup_tuple
;
1537 struct cleanup
*cleanup_list_data
;
1538 struct value_print_options opts
;
1540 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1541 ui_out_field_core_addr (uiout
, "addr", gdbarch
, addr
+ row_byte
);
1542 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr +
1544 cleanup_list_data
= make_cleanup_ui_out_list_begin_end (uiout
, "data");
1545 get_formatted_print_options (&opts
, word_format
);
1546 for (col
= 0, col_byte
= row_byte
;
1548 col
++, col_byte
+= word_size
)
1550 if (col_byte
+ word_size
> nr_bytes
)
1552 ui_out_field_string (uiout
, NULL
, "N/A");
1556 ui_file_rewind (stream
);
1557 print_scalar_formatted (mbuf
+ col_byte
, word_type
, &opts
,
1558 word_asize
, stream
);
1559 ui_out_field_stream (uiout
, NULL
, stream
);
1562 do_cleanups (cleanup_list_data
);
1567 ui_file_rewind (stream
);
1568 for (byte
= row_byte
;
1569 byte
< row_byte
+ word_size
* nr_cols
; byte
++)
1571 if (byte
>= nr_bytes
)
1572 fputc_unfiltered ('X', stream
);
1573 else if (mbuf
[byte
] < 32 || mbuf
[byte
] > 126)
1574 fputc_unfiltered (aschar
, stream
);
1576 fputc_unfiltered (mbuf
[byte
], stream
);
1578 ui_out_field_stream (uiout
, "ascii", stream
);
1580 do_cleanups (cleanup_tuple
);
1582 do_cleanups (cleanup_stream
);
1584 do_cleanups (cleanups
);
1588 mi_cmd_data_read_memory_bytes (char *command
, char **argv
, int argc
)
1590 struct gdbarch
*gdbarch
= get_current_arch ();
1591 struct ui_out
*uiout
= current_uiout
;
1592 struct cleanup
*cleanups
;
1595 memory_read_result_s
*read_result
;
1597 VEC(memory_read_result_s
) *result
;
1605 static const struct mi_opt opts
[] =
1607 {"o", OFFSET_OPT
, 1},
1613 int opt
= mi_getopt ("-data-read-memory-bytes", argc
, argv
, opts
,
1617 switch ((enum opt
) opt
)
1620 offset
= atol (oarg
);
1628 error (_("Usage: [ -o OFFSET ] ADDR LENGTH."));
1630 addr
= parse_and_eval_address (argv
[0]) + offset
;
1631 length
= atol (argv
[1]);
1633 result
= read_memory_robust (current_target
.beneath
, addr
, length
);
1635 cleanups
= make_cleanup (free_memory_read_result_vector
, result
);
1637 if (VEC_length (memory_read_result_s
, result
) == 0)
1638 error (_("Unable to read memory."));
1640 make_cleanup_ui_out_list_begin_end (uiout
, "memory");
1642 VEC_iterate (memory_read_result_s
, result
, ix
, read_result
);
1645 struct cleanup
*t
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1649 ui_out_field_core_addr (uiout
, "begin", gdbarch
, read_result
->begin
);
1650 ui_out_field_core_addr (uiout
, "offset", gdbarch
, read_result
->begin
1652 ui_out_field_core_addr (uiout
, "end", gdbarch
, read_result
->end
);
1654 data
= xmalloc ((read_result
->end
- read_result
->begin
) * 2 + 1);
1656 for (i
= 0, p
= data
;
1657 i
< (read_result
->end
- read_result
->begin
);
1660 sprintf (p
, "%02x", read_result
->data
[i
]);
1662 ui_out_field_string (uiout
, "contents", data
);
1666 do_cleanups (cleanups
);
1669 /* Implementation of the -data-write_memory command.
1671 COLUMN_OFFSET: optional argument. Must be preceded by '-o'. The
1672 offset from the beginning of the memory grid row where the cell to
1674 ADDR: start address of the row in the memory grid where the memory
1675 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
1676 the location to write to.
1677 FORMAT: a char indicating format for the ``word''. See
1679 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
1680 VALUE: value to be written into the memory address.
1682 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1687 mi_cmd_data_write_memory (char *command
, char **argv
, int argc
)
1689 struct gdbarch
*gdbarch
= get_current_arch ();
1690 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1693 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1694 enough when using a compiler other than GCC. */
1697 struct cleanup
*old_chain
;
1705 static const struct mi_opt opts
[] =
1707 {"o", OFFSET_OPT
, 1},
1713 int opt
= mi_getopt ("-data-write-memory", argc
, argv
, opts
,
1718 switch ((enum opt
) opt
)
1721 offset
= atol (oarg
);
1729 error (_("-data-write-memory: Usage: "
1730 "[-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE."));
1732 /* Extract all the arguments. */
1733 /* Start address of the memory dump. */
1734 addr
= parse_and_eval_address (argv
[0]);
1735 /* The size of the memory word. */
1736 word_size
= atol (argv
[2]);
1738 /* Calculate the real address of the write destination. */
1739 addr
+= (offset
* word_size
);
1741 /* Get the value as a number. */
1742 value
= parse_and_eval_address (argv
[3]);
1743 /* Get the value into an array. */
1744 buffer
= xmalloc (word_size
);
1745 old_chain
= make_cleanup (xfree
, buffer
);
1746 store_signed_integer (buffer
, word_size
, byte_order
, value
);
1747 /* Write it down to memory. */
1748 write_memory_with_notification (addr
, buffer
, word_size
);
1749 /* Free the buffer. */
1750 do_cleanups (old_chain
);
1753 /* Implementation of the -data-write-memory-bytes command.
1756 DATA: string of bytes to write at that address
1757 COUNT: number of bytes to be filled (decimal integer). */
1760 mi_cmd_data_write_memory_bytes (char *command
, char **argv
, int argc
)
1766 size_t len
, i
, steps
, remainder
;
1768 struct cleanup
*back_to
;
1770 if (argc
!= 2 && argc
!= 3)
1771 error (_("Usage: ADDR DATA [COUNT]."));
1773 addr
= parse_and_eval_address (argv
[0]);
1775 if (strlen (cdata
) % 2)
1776 error (_("Hex-encoded '%s' must have an even number of characters."),
1779 len
= strlen (cdata
)/2;
1781 count
= strtoul (argv
[2], NULL
, 10);
1785 databuf
= xmalloc (len
* sizeof (gdb_byte
));
1786 back_to
= make_cleanup (xfree
, databuf
);
1788 for (i
= 0; i
< len
; ++i
)
1791 if (sscanf (cdata
+ i
* 2, "%02x", &x
) != 1)
1792 error (_("Invalid argument"));
1793 databuf
[i
] = (gdb_byte
) x
;
1798 /* Pattern is made of less bytes than count:
1799 repeat pattern to fill memory. */
1800 data
= xmalloc (count
);
1801 make_cleanup (xfree
, data
);
1803 steps
= count
/ len
;
1804 remainder
= count
% len
;
1805 for (j
= 0; j
< steps
; j
++)
1806 memcpy (data
+ j
* len
, databuf
, len
);
1809 memcpy (data
+ steps
* len
, databuf
, remainder
);
1813 /* Pattern is longer than or equal to count:
1814 just copy count bytes. */
1818 write_memory_with_notification (addr
, data
, count
);
1820 do_cleanups (back_to
);
1824 mi_cmd_enable_timings (char *command
, char **argv
, int argc
)
1830 if (strcmp (argv
[0], "yes") == 0)
1832 else if (strcmp (argv
[0], "no") == 0)
1843 error (_("-enable-timings: Usage: %s {yes|no}"), command
);
1847 mi_cmd_list_features (char *command
, char **argv
, int argc
)
1851 struct cleanup
*cleanup
= NULL
;
1852 struct ui_out
*uiout
= current_uiout
;
1854 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "features");
1855 ui_out_field_string (uiout
, NULL
, "frozen-varobjs");
1856 ui_out_field_string (uiout
, NULL
, "pending-breakpoints");
1857 ui_out_field_string (uiout
, NULL
, "thread-info");
1858 ui_out_field_string (uiout
, NULL
, "data-read-memory-bytes");
1859 ui_out_field_string (uiout
, NULL
, "breakpoint-notifications");
1860 ui_out_field_string (uiout
, NULL
, "ada-task-info");
1861 ui_out_field_string (uiout
, NULL
, "language-option");
1862 ui_out_field_string (uiout
, NULL
, "info-gdb-mi-command");
1863 ui_out_field_string (uiout
, NULL
, "undefined-command-error-code");
1864 ui_out_field_string (uiout
, NULL
, "exec-run-start-option");
1866 if (ext_lang_initialized_p (get_ext_lang_defn (EXT_LANG_PYTHON
)))
1867 ui_out_field_string (uiout
, NULL
, "python");
1869 do_cleanups (cleanup
);
1873 error (_("-list-features should be passed no arguments"));
1877 mi_cmd_list_target_features (char *command
, char **argv
, int argc
)
1881 struct cleanup
*cleanup
= NULL
;
1882 struct ui_out
*uiout
= current_uiout
;
1884 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "features");
1886 ui_out_field_string (uiout
, NULL
, "async");
1887 if (target_can_execute_reverse
)
1888 ui_out_field_string (uiout
, NULL
, "reverse");
1889 do_cleanups (cleanup
);
1893 error (_("-list-target-features should be passed no arguments"));
1897 mi_cmd_add_inferior (char *command
, char **argv
, int argc
)
1899 struct inferior
*inf
;
1902 error (_("-add-inferior should be passed no arguments"));
1904 inf
= add_inferior_with_spaces ();
1906 ui_out_field_fmt (current_uiout
, "inferior", "i%d", inf
->num
);
1909 /* Callback used to find the first inferior other than the current
1913 get_other_inferior (struct inferior
*inf
, void *arg
)
1915 if (inf
== current_inferior ())
1922 mi_cmd_remove_inferior (char *command
, char **argv
, int argc
)
1925 struct inferior
*inf
;
1928 error (_("-remove-inferior should be passed a single argument"));
1930 if (sscanf (argv
[0], "i%d", &id
) != 1)
1931 error (_("the thread group id is syntactically invalid"));
1933 inf
= find_inferior_id (id
);
1935 error (_("the specified thread group does not exist"));
1938 error (_("cannot remove an active inferior"));
1940 if (inf
== current_inferior ())
1942 struct thread_info
*tp
= 0;
1943 struct inferior
*new_inferior
1944 = iterate_over_inferiors (get_other_inferior
, NULL
);
1946 if (new_inferior
== NULL
)
1947 error (_("Cannot remove last inferior"));
1949 set_current_inferior (new_inferior
);
1950 if (new_inferior
->pid
!= 0)
1951 tp
= any_thread_of_process (new_inferior
->pid
);
1952 switch_to_thread (tp
? tp
->ptid
: null_ptid
);
1953 set_current_program_space (new_inferior
->pspace
);
1956 delete_inferior_1 (inf
, 1 /* silent */);
1961 /* Execute a command within a safe environment.
1962 Return <0 for error; >=0 for ok.
1964 args->action will tell mi_execute_command what action
1965 to perfrom after the given command has executed (display/suppress
1966 prompt, display error). */
1969 captured_mi_execute_command (struct ui_out
*uiout
, struct mi_parse
*context
)
1971 struct cleanup
*cleanup
;
1974 current_command_ts
= context
->cmd_start
;
1976 current_token
= xstrdup (context
->token
);
1977 cleanup
= make_cleanup (free_current_contents
, ¤t_token
);
1979 running_result_record_printed
= 0;
1981 switch (context
->op
)
1984 /* A MI command was read from the input stream. */
1986 /* FIXME: gdb_???? */
1987 fprintf_unfiltered (raw_stdout
, " token=`%s' command=`%s' args=`%s'\n",
1988 context
->token
, context
->command
, context
->args
);
1990 mi_cmd_execute (context
);
1992 /* Print the result if there were no errors.
1994 Remember that on the way out of executing a command, you have
1995 to directly use the mi_interp's uiout, since the command
1996 could have reset the interpreter, in which case the current
1997 uiout will most likely crash in the mi_out_* routines. */
1998 if (!running_result_record_printed
)
2000 fputs_unfiltered (context
->token
, raw_stdout
);
2001 /* There's no particularly good reason why target-connect results
2002 in not ^done. Should kill ^connected for MI3. */
2003 fputs_unfiltered (strcmp (context
->command
, "target-select") == 0
2004 ? "^connected" : "^done", raw_stdout
);
2005 mi_out_put (uiout
, raw_stdout
);
2006 mi_out_rewind (uiout
);
2007 mi_print_timing_maybe ();
2008 fputs_unfiltered ("\n", raw_stdout
);
2011 /* The command does not want anything to be printed. In that
2012 case, the command probably should not have written anything
2013 to uiout, but in case it has written something, discard it. */
2014 mi_out_rewind (uiout
);
2021 /* A CLI command was read from the input stream. */
2022 /* This "feature" will be removed as soon as we have a
2023 complete set of mi commands. */
2024 /* Echo the command on the console. */
2025 fprintf_unfiltered (gdb_stdlog
, "%s\n", context
->command
);
2026 /* Call the "console" interpreter. */
2027 argv
[0] = "console";
2028 argv
[1] = context
->command
;
2029 mi_cmd_interpreter_exec ("-interpreter-exec", argv
, 2);
2031 /* If we changed interpreters, DON'T print out anything. */
2032 if (current_interp_named_p (INTERP_MI
)
2033 || current_interp_named_p (INTERP_MI1
)
2034 || current_interp_named_p (INTERP_MI2
)
2035 || current_interp_named_p (INTERP_MI3
))
2037 if (!running_result_record_printed
)
2039 fputs_unfiltered (context
->token
, raw_stdout
);
2040 fputs_unfiltered ("^done", raw_stdout
);
2041 mi_out_put (uiout
, raw_stdout
);
2042 mi_out_rewind (uiout
);
2043 mi_print_timing_maybe ();
2044 fputs_unfiltered ("\n", raw_stdout
);
2047 mi_out_rewind (uiout
);
2053 do_cleanups (cleanup
);
2056 /* Print a gdb exception to the MI output stream. */
2059 mi_print_exception (const char *token
, struct gdb_exception exception
)
2061 fputs_unfiltered (token
, raw_stdout
);
2062 fputs_unfiltered ("^error,msg=\"", raw_stdout
);
2063 if (exception
.message
== NULL
)
2064 fputs_unfiltered ("unknown error", raw_stdout
);
2066 fputstr_unfiltered (exception
.message
, '"', raw_stdout
);
2067 fputs_unfiltered ("\"", raw_stdout
);
2069 switch (exception
.error
)
2071 case UNDEFINED_COMMAND_ERROR
:
2072 fputs_unfiltered (",code=\"undefined-command\"", raw_stdout
);
2076 fputs_unfiltered ("\n", raw_stdout
);
2080 mi_execute_command (const char *cmd
, int from_tty
)
2083 struct mi_parse
*command
= NULL
;
2084 volatile struct gdb_exception exception
;
2086 /* This is to handle EOF (^D). We just quit gdb. */
2087 /* FIXME: we should call some API function here. */
2089 quit_force (NULL
, from_tty
);
2091 target_log_command (cmd
);
2093 TRY_CATCH (exception
, RETURN_MASK_ALL
)
2095 command
= mi_parse (cmd
, &token
);
2097 if (exception
.reason
< 0)
2099 mi_print_exception (token
, exception
);
2104 volatile struct gdb_exception result
;
2105 ptid_t previous_ptid
= inferior_ptid
;
2107 command
->token
= token
;
2111 command
->cmd_start
= (struct mi_timestamp
*)
2112 xmalloc (sizeof (struct mi_timestamp
));
2113 timestamp (command
->cmd_start
);
2116 TRY_CATCH (result
, RETURN_MASK_ALL
)
2118 captured_mi_execute_command (current_uiout
, command
);
2120 if (result
.reason
< 0)
2122 /* The command execution failed and error() was called
2124 mi_print_exception (command
->token
, result
);
2125 mi_out_rewind (current_uiout
);
2128 bpstat_do_actions ();
2130 if (/* The notifications are only output when the top-level
2131 interpreter (specified on the command line) is MI. */
2132 ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ()))
2133 /* Don't try report anything if there are no threads --
2134 the program is dead. */
2135 && thread_count () != 0
2136 /* -thread-select explicitly changes thread. If frontend uses that
2137 internally, we don't want to emit =thread-selected, since
2138 =thread-selected is supposed to indicate user's intentions. */
2139 && strcmp (command
->command
, "thread-select") != 0)
2141 struct mi_interp
*mi
= top_level_interpreter_data ();
2142 int report_change
= 0;
2144 if (command
->thread
== -1)
2146 report_change
= (!ptid_equal (previous_ptid
, null_ptid
)
2147 && !ptid_equal (inferior_ptid
, previous_ptid
)
2148 && !ptid_equal (inferior_ptid
, null_ptid
));
2150 else if (!ptid_equal (inferior_ptid
, null_ptid
))
2152 struct thread_info
*ti
= inferior_thread ();
2154 report_change
= (ti
->num
!= command
->thread
);
2159 struct thread_info
*ti
= inferior_thread ();
2161 target_terminal_ours ();
2162 fprintf_unfiltered (mi
->event_channel
,
2163 "thread-selected,id=\"%d\"",
2165 gdb_flush (mi
->event_channel
);
2169 mi_parse_free (command
);
2174 mi_cmd_execute (struct mi_parse
*parse
)
2176 struct cleanup
*cleanup
;
2177 enum language saved_language
;
2179 cleanup
= prepare_execute_command ();
2181 if (parse
->all
&& parse
->thread_group
!= -1)
2182 error (_("Cannot specify --thread-group together with --all"));
2184 if (parse
->all
&& parse
->thread
!= -1)
2185 error (_("Cannot specify --thread together with --all"));
2187 if (parse
->thread_group
!= -1 && parse
->thread
!= -1)
2188 error (_("Cannot specify --thread together with --thread-group"));
2190 if (parse
->frame
!= -1 && parse
->thread
== -1)
2191 error (_("Cannot specify --frame without --thread"));
2193 if (parse
->thread_group
!= -1)
2195 struct inferior
*inf
= find_inferior_id (parse
->thread_group
);
2196 struct thread_info
*tp
= 0;
2199 error (_("Invalid thread group for the --thread-group option"));
2201 set_current_inferior (inf
);
2202 /* This behaviour means that if --thread-group option identifies
2203 an inferior with multiple threads, then a random one will be
2204 picked. This is not a problem -- frontend should always
2205 provide --thread if it wishes to operate on a specific
2208 tp
= any_live_thread_of_process (inf
->pid
);
2209 switch_to_thread (tp
? tp
->ptid
: null_ptid
);
2210 set_current_program_space (inf
->pspace
);
2213 if (parse
->thread
!= -1)
2215 struct thread_info
*tp
= find_thread_id (parse
->thread
);
2218 error (_("Invalid thread id: %d"), parse
->thread
);
2220 if (is_exited (tp
->ptid
))
2221 error (_("Thread id: %d has terminated"), parse
->thread
);
2223 switch_to_thread (tp
->ptid
);
2226 if (parse
->frame
!= -1)
2228 struct frame_info
*fid
;
2229 int frame
= parse
->frame
;
2231 fid
= find_relative_frame (get_current_frame (), &frame
);
2233 /* find_relative_frame was successful */
2236 error (_("Invalid frame id: %d"), frame
);
2239 if (parse
->language
!= language_unknown
)
2241 make_cleanup_restore_current_language ();
2242 set_language (parse
->language
);
2245 current_context
= parse
;
2247 if (parse
->cmd
->suppress_notification
!= NULL
)
2249 make_cleanup_restore_integer (parse
->cmd
->suppress_notification
);
2250 *parse
->cmd
->suppress_notification
= 1;
2253 if (parse
->cmd
->argv_func
!= NULL
)
2255 parse
->cmd
->argv_func (parse
->command
, parse
->argv
, parse
->argc
);
2257 else if (parse
->cmd
->cli
.cmd
!= 0)
2259 /* FIXME: DELETE THIS. */
2260 /* The operation is still implemented by a cli command. */
2261 /* Must be a synchronous one. */
2262 mi_execute_cli_command (parse
->cmd
->cli
.cmd
, parse
->cmd
->cli
.args_p
,
2267 /* FIXME: DELETE THIS. */
2268 struct ui_file
*stb
;
2270 stb
= mem_fileopen ();
2272 fputs_unfiltered ("Undefined mi command: ", stb
);
2273 fputstr_unfiltered (parse
->command
, '"', stb
);
2274 fputs_unfiltered (" (missing implementation)", stb
);
2276 make_cleanup_ui_file_delete (stb
);
2279 do_cleanups (cleanup
);
2282 /* FIXME: This is just a hack so we can get some extra commands going.
2283 We don't want to channel things through the CLI, but call libgdb directly.
2284 Use only for synchronous commands. */
2287 mi_execute_cli_command (const char *cmd
, int args_p
, const char *args
)
2291 struct cleanup
*old_cleanups
;
2295 run
= xstrprintf ("%s %s", cmd
, args
);
2297 run
= xstrdup (cmd
);
2299 /* FIXME: gdb_???? */
2300 fprintf_unfiltered (gdb_stdout
, "cli=%s run=%s\n",
2302 old_cleanups
= make_cleanup (xfree
, run
);
2303 execute_command (run
, 0 /* from_tty */ );
2304 do_cleanups (old_cleanups
);
2310 mi_execute_async_cli_command (char *cli_command
, char **argv
, int argc
)
2312 struct cleanup
*old_cleanups
;
2316 run
= xstrprintf ("%s %s&", cli_command
, argc
? *argv
: "");
2318 run
= xstrprintf ("%s %s", cli_command
, argc
? *argv
: "");
2319 old_cleanups
= make_cleanup (xfree
, run
);
2321 execute_command (run
, 0 /* from_tty */ );
2323 /* Do this before doing any printing. It would appear that some
2324 print code leaves garbage around in the buffer. */
2325 do_cleanups (old_cleanups
);
2329 mi_load_progress (const char *section_name
,
2330 unsigned long sent_so_far
,
2331 unsigned long total_section
,
2332 unsigned long total_sent
,
2333 unsigned long grand_total
)
2335 struct timeval time_now
, delta
, update_threshold
;
2336 static struct timeval last_update
;
2337 static char *previous_sect_name
= NULL
;
2339 struct ui_out
*saved_uiout
;
2340 struct ui_out
*uiout
;
2342 /* This function is called through deprecated_show_load_progress
2343 which means uiout may not be correct. Fix it for the duration
2344 of this function. */
2345 saved_uiout
= current_uiout
;
2347 if (current_interp_named_p (INTERP_MI
)
2348 || current_interp_named_p (INTERP_MI2
))
2349 current_uiout
= mi_out_new (2);
2350 else if (current_interp_named_p (INTERP_MI1
))
2351 current_uiout
= mi_out_new (1);
2352 else if (current_interp_named_p (INTERP_MI3
))
2353 current_uiout
= mi_out_new (3);
2357 uiout
= current_uiout
;
2359 update_threshold
.tv_sec
= 0;
2360 update_threshold
.tv_usec
= 500000;
2361 gettimeofday (&time_now
, NULL
);
2363 delta
.tv_usec
= time_now
.tv_usec
- last_update
.tv_usec
;
2364 delta
.tv_sec
= time_now
.tv_sec
- last_update
.tv_sec
;
2366 if (delta
.tv_usec
< 0)
2369 delta
.tv_usec
+= 1000000L;
2372 new_section
= (previous_sect_name
?
2373 strcmp (previous_sect_name
, section_name
) : 1);
2376 struct cleanup
*cleanup_tuple
;
2378 xfree (previous_sect_name
);
2379 previous_sect_name
= xstrdup (section_name
);
2382 fputs_unfiltered (current_token
, raw_stdout
);
2383 fputs_unfiltered ("+download", raw_stdout
);
2384 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2385 ui_out_field_string (uiout
, "section", section_name
);
2386 ui_out_field_int (uiout
, "section-size", total_section
);
2387 ui_out_field_int (uiout
, "total-size", grand_total
);
2388 do_cleanups (cleanup_tuple
);
2389 mi_out_put (uiout
, raw_stdout
);
2390 fputs_unfiltered ("\n", raw_stdout
);
2391 gdb_flush (raw_stdout
);
2394 if (delta
.tv_sec
>= update_threshold
.tv_sec
&&
2395 delta
.tv_usec
>= update_threshold
.tv_usec
)
2397 struct cleanup
*cleanup_tuple
;
2399 last_update
.tv_sec
= time_now
.tv_sec
;
2400 last_update
.tv_usec
= time_now
.tv_usec
;
2402 fputs_unfiltered (current_token
, raw_stdout
);
2403 fputs_unfiltered ("+download", raw_stdout
);
2404 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2405 ui_out_field_string (uiout
, "section", section_name
);
2406 ui_out_field_int (uiout
, "section-sent", sent_so_far
);
2407 ui_out_field_int (uiout
, "section-size", total_section
);
2408 ui_out_field_int (uiout
, "total-sent", total_sent
);
2409 ui_out_field_int (uiout
, "total-size", grand_total
);
2410 do_cleanups (cleanup_tuple
);
2411 mi_out_put (uiout
, raw_stdout
);
2412 fputs_unfiltered ("\n", raw_stdout
);
2413 gdb_flush (raw_stdout
);
2417 current_uiout
= saved_uiout
;
2421 timestamp (struct mi_timestamp
*tv
)
2423 gettimeofday (&tv
->wallclock
, NULL
);
2424 #ifdef HAVE_GETRUSAGE
2425 getrusage (RUSAGE_SELF
, &rusage
);
2426 tv
->utime
.tv_sec
= rusage
.ru_utime
.tv_sec
;
2427 tv
->utime
.tv_usec
= rusage
.ru_utime
.tv_usec
;
2428 tv
->stime
.tv_sec
= rusage
.ru_stime
.tv_sec
;
2429 tv
->stime
.tv_usec
= rusage
.ru_stime
.tv_usec
;
2432 long usec
= get_run_time ();
2434 tv
->utime
.tv_sec
= usec
/1000000L;
2435 tv
->utime
.tv_usec
= usec
- 1000000L*tv
->utime
.tv_sec
;
2436 tv
->stime
.tv_sec
= 0;
2437 tv
->stime
.tv_usec
= 0;
2443 print_diff_now (struct mi_timestamp
*start
)
2445 struct mi_timestamp now
;
2448 print_diff (start
, &now
);
2452 mi_print_timing_maybe (void)
2454 /* If the command is -enable-timing then do_timings may be true
2455 whilst current_command_ts is not initialized. */
2456 if (do_timings
&& current_command_ts
)
2457 print_diff_now (current_command_ts
);
2461 timeval_diff (struct timeval start
, struct timeval end
)
2463 return ((end
.tv_sec
- start
.tv_sec
) * 1000000L)
2464 + (end
.tv_usec
- start
.tv_usec
);
2468 print_diff (struct mi_timestamp
*start
, struct mi_timestamp
*end
)
2472 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
2473 timeval_diff (start
->wallclock
, end
->wallclock
) / 1000000.0,
2474 timeval_diff (start
->utime
, end
->utime
) / 1000000.0,
2475 timeval_diff (start
->stime
, end
->stime
) / 1000000.0);
2479 mi_cmd_trace_define_variable (char *command
, char **argv
, int argc
)
2481 struct expression
*expr
;
2482 LONGEST initval
= 0;
2483 struct trace_state_variable
*tsv
;
2486 if (argc
!= 1 && argc
!= 2)
2487 error (_("Usage: -trace-define-variable VARIABLE [VALUE]"));
2491 error (_("Name of trace variable should start with '$'"));
2493 validate_trace_state_variable_name (name
);
2495 tsv
= find_trace_state_variable (name
);
2497 tsv
= create_trace_state_variable (name
);
2500 initval
= value_as_long (parse_and_eval (argv
[1]));
2502 tsv
->initial_value
= initval
;
2506 mi_cmd_trace_list_variables (char *command
, char **argv
, int argc
)
2509 error (_("-trace-list-variables: no arguments allowed"));
2511 tvariables_info_1 ();
2515 mi_cmd_trace_find (char *command
, char **argv
, int argc
)
2520 error (_("trace selection mode is required"));
2524 if (strcmp (mode
, "none") == 0)
2526 tfind_1 (tfind_number
, -1, 0, 0, 0);
2530 check_trace_running (current_trace_status ());
2532 if (strcmp (mode
, "frame-number") == 0)
2535 error (_("frame number is required"));
2536 tfind_1 (tfind_number
, atoi (argv
[1]), 0, 0, 0);
2538 else if (strcmp (mode
, "tracepoint-number") == 0)
2541 error (_("tracepoint number is required"));
2542 tfind_1 (tfind_tp
, atoi (argv
[1]), 0, 0, 0);
2544 else if (strcmp (mode
, "pc") == 0)
2547 error (_("PC is required"));
2548 tfind_1 (tfind_pc
, 0, parse_and_eval_address (argv
[1]), 0, 0);
2550 else if (strcmp (mode
, "pc-inside-range") == 0)
2553 error (_("Start and end PC are required"));
2554 tfind_1 (tfind_range
, 0, parse_and_eval_address (argv
[1]),
2555 parse_and_eval_address (argv
[2]), 0);
2557 else if (strcmp (mode
, "pc-outside-range") == 0)
2560 error (_("Start and end PC are required"));
2561 tfind_1 (tfind_outside
, 0, parse_and_eval_address (argv
[1]),
2562 parse_and_eval_address (argv
[2]), 0);
2564 else if (strcmp (mode
, "line") == 0)
2566 struct symtabs_and_lines sals
;
2567 struct symtab_and_line sal
;
2568 static CORE_ADDR start_pc
, end_pc
;
2569 struct cleanup
*back_to
;
2572 error (_("Line is required"));
2574 sals
= decode_line_with_current_source (argv
[1],
2575 DECODE_LINE_FUNFIRSTLINE
);
2576 back_to
= make_cleanup (xfree
, sals
.sals
);
2580 if (sal
.symtab
== 0)
2581 error (_("Could not find the specified line"));
2583 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2584 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, 0);
2586 error (_("Could not find the specified line"));
2588 do_cleanups (back_to
);
2591 error (_("Invalid mode '%s'"), mode
);
2593 if (has_stack_frames () || get_traceframe_number () >= 0)
2594 print_stack_frame (get_selected_frame (NULL
), 1, LOC_AND_ADDRESS
, 1);
2598 mi_cmd_trace_save (char *command
, char **argv
, int argc
)
2600 int target_saves
= 0;
2601 int generate_ctf
= 0;
2608 TARGET_SAVE_OPT
, CTF_OPT
2610 static const struct mi_opt opts
[] =
2612 {"r", TARGET_SAVE_OPT
, 0},
2613 {"ctf", CTF_OPT
, 0},
2619 int opt
= mi_getopt ("-trace-save", argc
, argv
, opts
,
2624 switch ((enum opt
) opt
)
2626 case TARGET_SAVE_OPT
:
2634 filename
= argv
[oind
];
2637 trace_save_ctf (filename
, target_saves
);
2639 trace_save_tfile (filename
, target_saves
);
2643 mi_cmd_trace_start (char *command
, char **argv
, int argc
)
2645 start_tracing (NULL
);
2649 mi_cmd_trace_status (char *command
, char **argv
, int argc
)
2651 trace_status_mi (0);
2655 mi_cmd_trace_stop (char *command
, char **argv
, int argc
)
2657 stop_tracing (NULL
);
2658 trace_status_mi (1);
2661 /* Implement the "-ada-task-info" command. */
2664 mi_cmd_ada_task_info (char *command
, char **argv
, int argc
)
2666 if (argc
!= 0 && argc
!= 1)
2667 error (_("Invalid MI command"));
2669 print_ada_task_info (current_uiout
, argv
[0], current_inferior ());
2672 /* Print EXPRESSION according to VALUES. */
2675 print_variable_or_computed (char *expression
, enum print_values values
)
2677 struct expression
*expr
;
2678 struct cleanup
*old_chain
;
2680 struct ui_file
*stb
;
2681 struct value_print_options opts
;
2683 struct ui_out
*uiout
= current_uiout
;
2685 stb
= mem_fileopen ();
2686 old_chain
= make_cleanup_ui_file_delete (stb
);
2688 expr
= parse_expression (expression
);
2690 make_cleanup (free_current_contents
, &expr
);
2692 if (values
== PRINT_SIMPLE_VALUES
)
2693 val
= evaluate_type (expr
);
2695 val
= evaluate_expression (expr
);
2697 if (values
!= PRINT_NO_VALUES
)
2698 make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2699 ui_out_field_string (uiout
, "name", expression
);
2703 case PRINT_SIMPLE_VALUES
:
2704 type
= check_typedef (value_type (val
));
2705 type_print (value_type (val
), "", stb
, -1);
2706 ui_out_field_stream (uiout
, "type", stb
);
2707 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
2708 && TYPE_CODE (type
) != TYPE_CODE_STRUCT
2709 && TYPE_CODE (type
) != TYPE_CODE_UNION
)
2711 struct value_print_options opts
;
2713 get_no_prettyformat_print_options (&opts
);
2715 common_val_print (val
, stb
, 0, &opts
, current_language
);
2716 ui_out_field_stream (uiout
, "value", stb
);
2719 case PRINT_ALL_VALUES
:
2721 struct value_print_options opts
;
2723 get_no_prettyformat_print_options (&opts
);
2725 common_val_print (val
, stb
, 0, &opts
, current_language
);
2726 ui_out_field_stream (uiout
, "value", stb
);
2731 do_cleanups (old_chain
);
2734 /* Implement the "-trace-frame-collected" command. */
2737 mi_cmd_trace_frame_collected (char *command
, char **argv
, int argc
)
2739 struct cleanup
*old_chain
;
2740 struct bp_location
*tloc
;
2742 struct collection_list
*clist
;
2743 struct collection_list tracepoint_list
, stepping_list
;
2744 struct traceframe_info
*tinfo
;
2746 int var_print_values
= PRINT_ALL_VALUES
;
2747 int comp_print_values
= PRINT_ALL_VALUES
;
2748 int registers_format
= 'x';
2749 int memory_contents
= 0;
2750 struct ui_out
*uiout
= current_uiout
;
2758 static const struct mi_opt opts
[] =
2760 {"-var-print-values", VAR_PRINT_VALUES
, 1},
2761 {"-comp-print-values", COMP_PRINT_VALUES
, 1},
2762 {"-registers-format", REGISTERS_FORMAT
, 1},
2763 {"-memory-contents", MEMORY_CONTENTS
, 0},
2770 int opt
= mi_getopt ("-trace-frame-collected", argc
, argv
, opts
,
2774 switch ((enum opt
) opt
)
2776 case VAR_PRINT_VALUES
:
2777 var_print_values
= mi_parse_print_values (oarg
);
2779 case COMP_PRINT_VALUES
:
2780 comp_print_values
= mi_parse_print_values (oarg
);
2782 case REGISTERS_FORMAT
:
2783 registers_format
= oarg
[0];
2784 case MEMORY_CONTENTS
:
2785 memory_contents
= 1;
2791 error (_("Usage: -trace-frame-collected "
2792 "[--var-print-values PRINT_VALUES] "
2793 "[--comp-print-values PRINT_VALUES] "
2794 "[--registers-format FORMAT]"
2795 "[--memory-contents]"));
2797 /* This throws an error is not inspecting a trace frame. */
2798 tloc
= get_traceframe_location (&stepping_frame
);
2800 /* This command only makes sense for the current frame, not the
2802 old_chain
= make_cleanup_restore_current_thread ();
2803 select_frame (get_current_frame ());
2805 encode_actions_and_make_cleanup (tloc
, &tracepoint_list
,
2809 clist
= &stepping_list
;
2811 clist
= &tracepoint_list
;
2813 tinfo
= get_traceframe_info ();
2815 /* Explicitly wholly collected variables. */
2817 struct cleanup
*list_cleanup
;
2821 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
,
2822 "explicit-variables");
2823 for (i
= 0; VEC_iterate (char_ptr
, clist
->wholly_collected
, i
, p
); i
++)
2824 print_variable_or_computed (p
, var_print_values
);
2825 do_cleanups (list_cleanup
);
2828 /* Computed expressions. */
2830 struct cleanup
*list_cleanup
;
2835 = make_cleanup_ui_out_list_begin_end (uiout
,
2836 "computed-expressions");
2837 for (i
= 0; VEC_iterate (char_ptr
, clist
->computed
, i
, p
); i
++)
2838 print_variable_or_computed (p
, comp_print_values
);
2839 do_cleanups (list_cleanup
);
2842 /* Registers. Given pseudo-registers, and that some architectures
2843 (like MIPS) actually hide the raw registers, we don't go through
2844 the trace frame info, but instead consult the register cache for
2845 register availability. */
2847 struct cleanup
*list_cleanup
;
2848 struct frame_info
*frame
;
2849 struct gdbarch
*gdbarch
;
2853 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "registers");
2855 frame
= get_selected_frame (NULL
);
2856 gdbarch
= get_frame_arch (frame
);
2857 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
2859 for (regnum
= 0; regnum
< numregs
; regnum
++)
2861 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
2862 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
2865 output_register (frame
, regnum
, registers_format
, 1);
2868 do_cleanups (list_cleanup
);
2871 /* Trace state variables. */
2873 struct cleanup
*list_cleanup
;
2878 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "tvars");
2881 make_cleanup (free_current_contents
, &tsvname
);
2883 for (i
= 0; VEC_iterate (int, tinfo
->tvars
, i
, tvar
); i
++)
2885 struct cleanup
*cleanup_child
;
2886 struct trace_state_variable
*tsv
;
2888 tsv
= find_trace_state_variable_by_number (tvar
);
2890 cleanup_child
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2894 tsvname
= xrealloc (tsvname
, strlen (tsv
->name
) + 2);
2896 strcpy (tsvname
+ 1, tsv
->name
);
2897 ui_out_field_string (uiout
, "name", tsvname
);
2899 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
2901 ui_out_field_int (uiout
, "current", tsv
->value
);
2905 ui_out_field_skip (uiout
, "name");
2906 ui_out_field_skip (uiout
, "current");
2909 do_cleanups (cleanup_child
);
2912 do_cleanups (list_cleanup
);
2917 struct cleanup
*list_cleanup
;
2918 VEC(mem_range_s
) *available_memory
= NULL
;
2919 struct mem_range
*r
;
2922 traceframe_available_memory (&available_memory
, 0, ULONGEST_MAX
);
2923 make_cleanup (VEC_cleanup(mem_range_s
), &available_memory
);
2925 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "memory");
2927 for (i
= 0; VEC_iterate (mem_range_s
, available_memory
, i
, r
); i
++)
2929 struct cleanup
*cleanup_child
;
2931 struct gdbarch
*gdbarch
= target_gdbarch ();
2933 cleanup_child
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2935 ui_out_field_core_addr (uiout
, "address", gdbarch
, r
->start
);
2936 ui_out_field_int (uiout
, "length", r
->length
);
2938 data
= xmalloc (r
->length
);
2939 make_cleanup (xfree
, data
);
2941 if (memory_contents
)
2943 if (target_read_memory (r
->start
, data
, r
->length
) == 0)
2948 data_str
= xmalloc (r
->length
* 2 + 1);
2949 make_cleanup (xfree
, data_str
);
2951 for (m
= 0, p
= data_str
; m
< r
->length
; ++m
, p
+= 2)
2952 sprintf (p
, "%02x", data
[m
]);
2953 ui_out_field_string (uiout
, "contents", data_str
);
2956 ui_out_field_skip (uiout
, "contents");
2958 do_cleanups (cleanup_child
);
2961 do_cleanups (list_cleanup
);
2964 do_cleanups (old_chain
);
2968 _initialize_mi_main (void)
2970 struct cmd_list_element
*c
;
2972 add_setshow_boolean_cmd ("mi-async", class_run
,
2974 Set whether MI asynchronous mode is enabled."), _("\
2975 Show whether MI asynchronous mode is enabled."), _("\
2976 Tells GDB whether MI should be in asynchronous mode."),
2977 set_mi_async_command
,
2978 show_mi_async_command
,
2982 /* Alias old "target-async" to "mi-async". */
2983 c
= add_alias_cmd ("target-async", "mi-async", class_run
, 0, &setlist
);
2984 deprecate_cmd (c
, "set mi-async");
2985 c
= add_alias_cmd ("target-async", "mi-async", class_run
, 0, &showlist
);
2986 deprecate_cmd (c
, "show mi-async");