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"
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"
60 #if defined HAVE_SYS_RESOURCE_H
61 #include <sys/resource.h>
75 struct ui_file
*raw_stdout
;
77 /* This is used to pass the current command timestamp down to
78 continuation routines. */
79 static struct mi_timestamp
*current_command_ts
;
81 static int do_timings
= 0;
84 /* Few commands would like to know if options like --thread-group were
85 explicitly specified. This variable keeps the current parsed
86 command including all option, and make it possible. */
87 static struct mi_parse
*current_context
;
89 int running_result_record_printed
= 1;
91 /* Flag indicating that the target has proceeded since the last
92 command was issued. */
95 extern void _initialize_mi_main (void);
96 static void mi_cmd_execute (struct mi_parse
*parse
);
98 static void mi_execute_cli_command (const char *cmd
, int args_p
,
100 static void mi_execute_async_cli_command (char *cli_command
,
101 char **argv
, int argc
);
102 static int register_changed_p (int regnum
, struct regcache
*,
104 static void output_register (struct frame_info
*, int regnum
, int format
,
105 int skip_unavailable
);
107 /* Controls whether the frontend wants MI in async mode. */
108 static int mi_async
= 0;
110 /* The set command writes to this variable. If the inferior is
111 executing, mi_async is *not* updated. */
112 static int mi_async_1
= 0;
115 set_mi_async_command (char *args
, int from_tty
,
116 struct cmd_list_element
*c
)
118 if (have_live_inferiors ())
120 mi_async_1
= mi_async
;
121 error (_("Cannot change this setting while the inferior is running."));
124 mi_async
= mi_async_1
;
128 show_mi_async_command (struct ui_file
*file
, int from_tty
,
129 struct cmd_list_element
*c
,
132 fprintf_filtered (file
,
133 _("Whether MI is in asynchronous mode is %s.\n"),
137 /* A wrapper for target_can_async_p that takes the MI setting into
143 return mi_async
&& target_can_async_p ();
146 /* Command implementations. FIXME: Is this libgdb? No. This is the MI
147 layer that calls libgdb. Any operation used in the below should be
150 static void timestamp (struct mi_timestamp
*tv
);
152 static void print_diff_now (struct mi_timestamp
*start
);
153 static void print_diff (struct mi_timestamp
*start
, struct mi_timestamp
*end
);
156 mi_cmd_gdb_exit (char *command
, char **argv
, int argc
)
158 /* We have to print everything right here because we never return. */
160 fputs_unfiltered (current_token
, raw_stdout
);
161 fputs_unfiltered ("^exit\n", raw_stdout
);
162 mi_out_put (current_uiout
, raw_stdout
);
163 gdb_flush (raw_stdout
);
164 /* FIXME: The function called is not yet a formal libgdb function. */
165 quit_force (NULL
, FROM_TTY
);
169 mi_cmd_exec_next (char *command
, char **argv
, int argc
)
171 /* FIXME: Should call a libgdb function, not a cli wrapper. */
172 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
173 mi_execute_async_cli_command ("reverse-next", argv
+ 1, argc
- 1);
175 mi_execute_async_cli_command ("next", argv
, argc
);
179 mi_cmd_exec_next_instruction (char *command
, char **argv
, int argc
)
181 /* FIXME: Should call a libgdb function, not a cli wrapper. */
182 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
183 mi_execute_async_cli_command ("reverse-nexti", argv
+ 1, argc
- 1);
185 mi_execute_async_cli_command ("nexti", argv
, argc
);
189 mi_cmd_exec_step (char *command
, char **argv
, int argc
)
191 /* FIXME: Should call a libgdb function, not a cli wrapper. */
192 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
193 mi_execute_async_cli_command ("reverse-step", argv
+ 1, argc
- 1);
195 mi_execute_async_cli_command ("step", argv
, argc
);
199 mi_cmd_exec_step_instruction (char *command
, char **argv
, int argc
)
201 /* FIXME: Should call a libgdb function, not a cli wrapper. */
202 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
203 mi_execute_async_cli_command ("reverse-stepi", argv
+ 1, argc
- 1);
205 mi_execute_async_cli_command ("stepi", argv
, argc
);
209 mi_cmd_exec_finish (char *command
, char **argv
, int argc
)
211 /* FIXME: Should call a libgdb function, not a cli wrapper. */
212 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
213 mi_execute_async_cli_command ("reverse-finish", argv
+ 1, argc
- 1);
215 mi_execute_async_cli_command ("finish", argv
, argc
);
219 mi_cmd_exec_return (char *command
, char **argv
, int argc
)
221 /* This command doesn't really execute the target, it just pops the
222 specified number of frames. */
224 /* Call return_command with from_tty argument equal to 0 so as to
225 avoid being queried. */
226 return_command (*argv
, 0);
228 /* Call return_command with from_tty argument equal to 0 so as to
229 avoid being queried. */
230 return_command (NULL
, 0);
232 /* Because we have called return_command with from_tty = 0, we need
233 to print the frame here. */
234 print_stack_frame (get_selected_frame (NULL
), 1, LOC_AND_ADDRESS
, 1);
238 mi_cmd_exec_jump (char *args
, char **argv
, int argc
)
240 /* FIXME: Should call a libgdb function, not a cli wrapper. */
241 mi_execute_async_cli_command ("jump", argv
, argc
);
245 proceed_thread (struct thread_info
*thread
, int pid
)
247 if (!is_stopped (thread
->ptid
))
250 if (pid
!= 0 && ptid_get_pid (thread
->ptid
) != pid
)
253 switch_to_thread (thread
->ptid
);
254 clear_proceed_status (0);
255 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
, 0);
259 proceed_thread_callback (struct thread_info
*thread
, void *arg
)
261 int pid
= *(int *)arg
;
263 proceed_thread (thread
, pid
);
268 exec_continue (char **argv
, int argc
)
270 prepare_execution_command (¤t_target
, mi_async_p ());
274 /* In non-stop mode, 'resume' always resumes a single thread.
275 Therefore, to resume all threads of the current inferior, or
276 all threads in all inferiors, we need to iterate over
279 See comment on infcmd.c:proceed_thread_callback for rationale. */
280 if (current_context
->all
|| current_context
->thread_group
!= -1)
283 struct cleanup
*back_to
= make_cleanup_restore_current_thread ();
285 if (!current_context
->all
)
288 = find_inferior_id (current_context
->thread_group
);
292 iterate_over_threads (proceed_thread_callback
, &pid
);
293 do_cleanups (back_to
);
302 struct cleanup
*back_to
= make_cleanup_restore_integer (&sched_multi
);
304 if (current_context
->all
)
311 /* In all-stop mode, -exec-continue traditionally resumed
312 either all threads, or one thread, depending on the
313 'scheduler-locking' variable. Let's continue to do the
317 do_cleanups (back_to
);
322 exec_direction_forward (void *notused
)
324 execution_direction
= EXEC_FORWARD
;
328 exec_reverse_continue (char **argv
, int argc
)
330 enum exec_direction_kind dir
= execution_direction
;
331 struct cleanup
*old_chain
;
333 if (dir
== EXEC_REVERSE
)
334 error (_("Already in reverse mode."));
336 if (!target_can_execute_reverse
)
337 error (_("Target %s does not support this command."), target_shortname
);
339 old_chain
= make_cleanup (exec_direction_forward
, NULL
);
340 execution_direction
= EXEC_REVERSE
;
341 exec_continue (argv
, argc
);
342 do_cleanups (old_chain
);
346 mi_cmd_exec_continue (char *command
, char **argv
, int argc
)
348 if (argc
> 0 && strcmp (argv
[0], "--reverse") == 0)
349 exec_reverse_continue (argv
+ 1, argc
- 1);
351 exec_continue (argv
, argc
);
355 interrupt_thread_callback (struct thread_info
*thread
, void *arg
)
357 int pid
= *(int *)arg
;
359 if (!is_running (thread
->ptid
))
362 if (ptid_get_pid (thread
->ptid
) != pid
)
365 target_stop (thread
->ptid
);
369 /* Interrupt the execution of the target. Note how we must play
370 around with the token variables, in order to display the current
371 token in the result of the interrupt command, and the previous
372 execution token when the target finally stops. See comments in
376 mi_cmd_exec_interrupt (char *command
, char **argv
, int argc
)
378 /* In all-stop mode, everything stops, so we don't need to try
379 anything specific. */
382 interrupt_target_1 (0);
386 if (current_context
->all
)
388 /* This will interrupt all threads in all inferiors. */
389 interrupt_target_1 (1);
391 else if (current_context
->thread_group
!= -1)
393 struct inferior
*inf
= find_inferior_id (current_context
->thread_group
);
395 iterate_over_threads (interrupt_thread_callback
, &inf
->pid
);
399 /* Interrupt just the current thread -- either explicitly
400 specified via --thread or whatever was current before
401 MI command was sent. */
402 interrupt_target_1 (0);
406 /* Callback for iterate_over_inferiors which starts the execution
407 of the given inferior.
409 ARG is a pointer to an integer whose value, if non-zero, indicates
410 that the program should be stopped when reaching the main subprogram
411 (similar to what the CLI "start" command does). */
414 run_one_inferior (struct inferior
*inf
, void *arg
)
416 int start_p
= *(int *) arg
;
417 const char *run_cmd
= start_p
? "start" : "run";
421 if (inf
->pid
!= ptid_get_pid (inferior_ptid
))
423 struct thread_info
*tp
;
425 tp
= any_thread_of_process (inf
->pid
);
427 error (_("Inferior has no threads."));
429 switch_to_thread (tp
->ptid
);
434 set_current_inferior (inf
);
435 switch_to_thread (null_ptid
);
436 set_current_program_space (inf
->pspace
);
438 mi_execute_cli_command (run_cmd
, mi_async_p (),
439 mi_async_p () ? "&" : NULL
);
444 mi_cmd_exec_run (char *command
, char **argv
, int argc
)
449 /* Parse the command options. */
454 static const struct mi_opt opts
[] =
456 {"-start", START_OPT
, 0},
465 int opt
= mi_getopt ("-exec-run", argc
, argv
, opts
, &oind
, &oarg
);
469 switch ((enum opt
) opt
)
477 /* This command does not accept any argument. Make sure the user
478 did not provide any. */
480 error (_("Invalid argument: %s"), argv
[oind
]);
482 if (current_context
->all
)
484 struct cleanup
*back_to
= save_current_space_and_thread ();
486 iterate_over_inferiors (run_one_inferior
, &start_p
);
487 do_cleanups (back_to
);
491 const char *run_cmd
= start_p
? "start" : "run";
493 mi_execute_cli_command (run_cmd
, mi_async_p (),
494 mi_async_p () ? "&" : NULL
);
500 find_thread_of_process (struct thread_info
*ti
, void *p
)
504 if (ptid_get_pid (ti
->ptid
) == pid
&& !is_exited (ti
->ptid
))
511 mi_cmd_target_detach (char *command
, char **argv
, int argc
)
513 if (argc
!= 0 && argc
!= 1)
514 error (_("Usage: -target-detach [pid | thread-group]"));
518 struct thread_info
*tp
;
522 /* First see if we are dealing with a thread-group id. */
525 struct inferior
*inf
;
526 int id
= strtoul (argv
[0] + 1, &end
, 0);
529 error (_("Invalid syntax of thread-group id '%s'"), argv
[0]);
531 inf
= find_inferior_id (id
);
533 error (_("Non-existent thread-group id '%d'"), id
);
539 /* We must be dealing with a pid. */
540 pid
= strtol (argv
[0], &end
, 10);
543 error (_("Invalid identifier '%s'"), argv
[0]);
546 /* Pick any thread in the desired process. Current
547 target_detach detaches from the parent of inferior_ptid. */
548 tp
= iterate_over_threads (find_thread_of_process
, &pid
);
550 error (_("Thread group is empty"));
552 switch_to_thread (tp
->ptid
);
555 detach_command (NULL
, 0);
559 mi_cmd_thread_select (char *command
, char **argv
, int argc
)
562 char *mi_error_message
;
565 error (_("-thread-select: USAGE: threadnum."));
567 rc
= gdb_thread_select (current_uiout
, argv
[0], &mi_error_message
);
569 if (rc
== GDB_RC_FAIL
)
571 make_cleanup (xfree
, mi_error_message
);
572 error ("%s", mi_error_message
);
577 mi_cmd_thread_list_ids (char *command
, char **argv
, int argc
)
580 char *mi_error_message
;
583 error (_("-thread-list-ids: No arguments required."));
585 rc
= gdb_list_thread_ids (current_uiout
, &mi_error_message
);
587 if (rc
== GDB_RC_FAIL
)
589 make_cleanup (xfree
, mi_error_message
);
590 error ("%s", mi_error_message
);
595 mi_cmd_thread_info (char *command
, char **argv
, int argc
)
597 if (argc
!= 0 && argc
!= 1)
598 error (_("Invalid MI command"));
600 print_thread_info (current_uiout
, argv
[0], -1);
603 struct collect_cores_data
611 collect_cores (struct thread_info
*ti
, void *xdata
)
613 struct collect_cores_data
*data
= xdata
;
615 if (ptid_get_pid (ti
->ptid
) == data
->pid
)
617 int core
= target_core_of_thread (ti
->ptid
);
620 VEC_safe_push (int, data
->cores
, core
);
627 unique (int *b
, int *e
)
637 struct print_one_inferior_data
640 VEC (int) *inferiors
;
644 print_one_inferior (struct inferior
*inferior
, void *xdata
)
646 struct print_one_inferior_data
*top_data
= xdata
;
647 struct ui_out
*uiout
= current_uiout
;
649 if (VEC_empty (int, top_data
->inferiors
)
650 || bsearch (&(inferior
->pid
), VEC_address (int, top_data
->inferiors
),
651 VEC_length (int, top_data
->inferiors
), sizeof (int),
652 compare_positive_ints
))
654 struct collect_cores_data data
;
655 struct cleanup
*back_to
656 = make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
658 ui_out_field_fmt (uiout
, "id", "i%d", inferior
->num
);
659 ui_out_field_string (uiout
, "type", "process");
660 if (inferior
->has_exit_code
)
661 ui_out_field_string (uiout
, "exit-code",
662 int_string (inferior
->exit_code
, 8, 0, 0, 1));
663 if (inferior
->pid
!= 0)
664 ui_out_field_int (uiout
, "pid", inferior
->pid
);
666 if (inferior
->pspace
->pspace_exec_filename
!= NULL
)
668 ui_out_field_string (uiout
, "executable",
669 inferior
->pspace
->pspace_exec_filename
);
673 if (inferior
->pid
!= 0)
675 data
.pid
= inferior
->pid
;
676 iterate_over_threads (collect_cores
, &data
);
679 if (!VEC_empty (int, data
.cores
))
682 struct cleanup
*back_to_2
=
683 make_cleanup_ui_out_list_begin_end (uiout
, "cores");
685 qsort (VEC_address (int, data
.cores
),
686 VEC_length (int, data
.cores
), sizeof (int),
687 compare_positive_ints
);
689 b
= VEC_address (int, data
.cores
);
690 e
= b
+ VEC_length (int, data
.cores
);
694 ui_out_field_int (uiout
, NULL
, *b
);
696 do_cleanups (back_to_2
);
699 if (top_data
->recurse
)
700 print_thread_info (uiout
, NULL
, inferior
->pid
);
702 do_cleanups (back_to
);
708 /* Output a field named 'cores' with a list as the value. The
709 elements of the list are obtained by splitting 'cores' on
713 output_cores (struct ui_out
*uiout
, const char *field_name
, const char *xcores
)
715 struct cleanup
*back_to
= make_cleanup_ui_out_list_begin_end (uiout
,
717 char *cores
= xstrdup (xcores
);
720 make_cleanup (xfree
, cores
);
722 for (p
= strtok (p
, ","); p
; p
= strtok (NULL
, ","))
723 ui_out_field_string (uiout
, NULL
, p
);
725 do_cleanups (back_to
);
729 free_vector_of_ints (void *xvector
)
731 VEC (int) **vector
= xvector
;
733 VEC_free (int, *vector
);
737 do_nothing (splay_tree_key k
)
742 free_vector_of_osdata_items (splay_tree_value xvalue
)
744 VEC (osdata_item_s
) *value
= (VEC (osdata_item_s
) *) xvalue
;
746 /* We don't free the items itself, it will be done separately. */
747 VEC_free (osdata_item_s
, value
);
751 splay_tree_int_comparator (splay_tree_key xa
, splay_tree_key xb
)
760 free_splay_tree (void *xt
)
763 splay_tree_delete (t
);
767 list_available_thread_groups (VEC (int) *ids
, int recurse
)
770 struct osdata_item
*item
;
772 struct ui_out
*uiout
= current_uiout
;
773 struct cleanup
*cleanup
;
775 /* This keeps a map from integer (pid) to VEC (struct osdata_item *)*
776 The vector contains information about all threads for the given pid.
777 This is assigned an initial value to avoid "may be used uninitialized"
779 splay_tree tree
= NULL
;
781 /* get_osdata will throw if it cannot return data. */
782 data
= get_osdata ("processes");
783 cleanup
= make_cleanup_osdata_free (data
);
787 struct osdata
*threads
= get_osdata ("threads");
789 make_cleanup_osdata_free (threads
);
790 tree
= splay_tree_new (splay_tree_int_comparator
,
792 free_vector_of_osdata_items
);
793 make_cleanup (free_splay_tree
, tree
);
796 VEC_iterate (osdata_item_s
, threads
->items
,
800 const char *pid
= get_osdata_column (item
, "pid");
801 int pid_i
= strtoul (pid
, NULL
, 0);
802 VEC (osdata_item_s
) *vec
= 0;
804 splay_tree_node n
= splay_tree_lookup (tree
, pid_i
);
807 VEC_safe_push (osdata_item_s
, vec
, item
);
808 splay_tree_insert (tree
, pid_i
, (splay_tree_value
)vec
);
812 vec
= (VEC (osdata_item_s
) *) n
->value
;
813 VEC_safe_push (osdata_item_s
, vec
, item
);
814 n
->value
= (splay_tree_value
) vec
;
819 make_cleanup_ui_out_list_begin_end (uiout
, "groups");
822 VEC_iterate (osdata_item_s
, data
->items
,
826 struct cleanup
*back_to
;
828 const char *pid
= get_osdata_column (item
, "pid");
829 const char *cmd
= get_osdata_column (item
, "command");
830 const char *user
= get_osdata_column (item
, "user");
831 const char *cores
= get_osdata_column (item
, "cores");
833 int pid_i
= strtoul (pid
, NULL
, 0);
835 /* At present, the target will return all available processes
836 and if information about specific ones was required, we filter
837 undesired processes here. */
838 if (ids
&& bsearch (&pid_i
, VEC_address (int, ids
),
839 VEC_length (int, ids
),
840 sizeof (int), compare_positive_ints
) == NULL
)
844 back_to
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
846 ui_out_field_fmt (uiout
, "id", "%s", pid
);
847 ui_out_field_string (uiout
, "type", "process");
849 ui_out_field_string (uiout
, "description", cmd
);
851 ui_out_field_string (uiout
, "user", user
);
853 output_cores (uiout
, "cores", cores
);
857 splay_tree_node n
= splay_tree_lookup (tree
, pid_i
);
860 VEC (osdata_item_s
) *children
= (VEC (osdata_item_s
) *) n
->value
;
861 struct osdata_item
*child
;
864 make_cleanup_ui_out_list_begin_end (uiout
, "threads");
867 VEC_iterate (osdata_item_s
, children
, ix_child
, child
);
870 struct cleanup
*back_to_2
=
871 make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
872 const char *tid
= get_osdata_column (child
, "tid");
873 const char *tcore
= get_osdata_column (child
, "core");
875 ui_out_field_string (uiout
, "id", tid
);
877 ui_out_field_string (uiout
, "core", tcore
);
879 do_cleanups (back_to_2
);
884 do_cleanups (back_to
);
887 do_cleanups (cleanup
);
891 mi_cmd_list_thread_groups (char *command
, char **argv
, int argc
)
893 struct ui_out
*uiout
= current_uiout
;
894 struct cleanup
*back_to
;
901 AVAILABLE_OPT
, RECURSE_OPT
903 static const struct mi_opt opts
[] =
905 {"-available", AVAILABLE_OPT
, 0},
906 {"-recurse", RECURSE_OPT
, 1},
915 int opt
= mi_getopt ("-list-thread-groups", argc
, argv
, opts
,
920 switch ((enum opt
) opt
)
926 if (strcmp (oarg
, "0") == 0)
928 else if (strcmp (oarg
, "1") == 0)
931 error (_("only '0' and '1' are valid values "
932 "for the '--recurse' option"));
937 for (; oind
< argc
; ++oind
)
942 if (*(argv
[oind
]) != 'i')
943 error (_("invalid syntax of group id '%s'"), argv
[oind
]);
945 inf
= strtoul (argv
[oind
] + 1, &end
, 0);
948 error (_("invalid syntax of group id '%s'"), argv
[oind
]);
949 VEC_safe_push (int, ids
, inf
);
951 if (VEC_length (int, ids
) > 1)
952 qsort (VEC_address (int, ids
),
953 VEC_length (int, ids
),
954 sizeof (int), compare_positive_ints
);
956 back_to
= make_cleanup (free_vector_of_ints
, &ids
);
960 list_available_thread_groups (ids
, recurse
);
962 else if (VEC_length (int, ids
) == 1)
964 /* Local thread groups, single id. */
965 int id
= *VEC_address (int, ids
);
966 struct inferior
*inf
= find_inferior_id (id
);
969 error (_("Non-existent thread group id '%d'"), id
);
971 print_thread_info (uiout
, NULL
, inf
->pid
);
975 struct print_one_inferior_data data
;
977 data
.recurse
= recurse
;
978 data
.inferiors
= ids
;
980 /* Local thread groups. Either no explicit ids -- and we
981 print everything, or several explicit ids. In both cases,
982 we print more than one group, and have to use 'groups'
983 as the top-level element. */
984 make_cleanup_ui_out_list_begin_end (uiout
, "groups");
985 update_thread_list ();
986 iterate_over_inferiors (print_one_inferior
, &data
);
989 do_cleanups (back_to
);
993 mi_cmd_data_list_register_names (char *command
, char **argv
, int argc
)
995 struct gdbarch
*gdbarch
;
996 struct ui_out
*uiout
= current_uiout
;
999 struct cleanup
*cleanup
;
1001 /* Note that the test for a valid register must include checking the
1002 gdbarch_register_name because gdbarch_num_regs may be allocated
1003 for the union of the register sets within a family of related
1004 processors. In this case, some entries of gdbarch_register_name
1005 will change depending upon the particular processor being
1008 gdbarch
= get_current_arch ();
1009 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1011 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "register-names");
1013 if (argc
== 0) /* No args, just do all the regs. */
1019 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1020 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1021 ui_out_field_string (uiout
, NULL
, "");
1023 ui_out_field_string (uiout
, NULL
,
1024 gdbarch_register_name (gdbarch
, regnum
));
1028 /* Else, list of register #s, just do listed regs. */
1029 for (i
= 0; i
< argc
; i
++)
1031 regnum
= atoi (argv
[i
]);
1032 if (regnum
< 0 || regnum
>= numregs
)
1033 error (_("bad register number"));
1035 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1036 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1037 ui_out_field_string (uiout
, NULL
, "");
1039 ui_out_field_string (uiout
, NULL
,
1040 gdbarch_register_name (gdbarch
, regnum
));
1042 do_cleanups (cleanup
);
1046 mi_cmd_data_list_changed_registers (char *command
, char **argv
, int argc
)
1048 static struct regcache
*this_regs
= NULL
;
1049 struct ui_out
*uiout
= current_uiout
;
1050 struct regcache
*prev_regs
;
1051 struct gdbarch
*gdbarch
;
1052 int regnum
, numregs
, changed
;
1054 struct cleanup
*cleanup
;
1056 /* The last time we visited this function, the current frame's
1057 register contents were saved in THIS_REGS. Move THIS_REGS over
1058 to PREV_REGS, and refresh THIS_REGS with the now-current register
1061 prev_regs
= this_regs
;
1062 this_regs
= frame_save_as_regcache (get_selected_frame (NULL
));
1063 cleanup
= make_cleanup_regcache_xfree (prev_regs
);
1065 /* Note that the test for a valid register must include checking the
1066 gdbarch_register_name because gdbarch_num_regs may be allocated
1067 for the union of the register sets within a family of related
1068 processors. In this case, some entries of gdbarch_register_name
1069 will change depending upon the particular processor being
1072 gdbarch
= get_regcache_arch (this_regs
);
1073 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1075 make_cleanup_ui_out_list_begin_end (uiout
, "changed-registers");
1079 /* No args, just do all the regs. */
1084 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1085 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1087 changed
= register_changed_p (regnum
, prev_regs
, this_regs
);
1089 error (_("-data-list-changed-registers: "
1090 "Unable to read register contents."));
1092 ui_out_field_int (uiout
, NULL
, regnum
);
1096 /* Else, list of register #s, just do listed regs. */
1097 for (i
= 0; i
< argc
; i
++)
1099 regnum
= atoi (argv
[i
]);
1103 && gdbarch_register_name (gdbarch
, regnum
) != NULL
1104 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
1106 changed
= register_changed_p (regnum
, prev_regs
, this_regs
);
1108 error (_("-data-list-changed-registers: "
1109 "Unable to read register contents."));
1111 ui_out_field_int (uiout
, NULL
, regnum
);
1114 error (_("bad register number"));
1116 do_cleanups (cleanup
);
1120 register_changed_p (int regnum
, struct regcache
*prev_regs
,
1121 struct regcache
*this_regs
)
1123 struct gdbarch
*gdbarch
= get_regcache_arch (this_regs
);
1124 gdb_byte prev_buffer
[MAX_REGISTER_SIZE
];
1125 gdb_byte this_buffer
[MAX_REGISTER_SIZE
];
1126 enum register_status prev_status
;
1127 enum register_status this_status
;
1129 /* First time through or after gdbarch change consider all registers
1131 if (!prev_regs
|| get_regcache_arch (prev_regs
) != gdbarch
)
1134 /* Get register contents and compare. */
1135 prev_status
= regcache_cooked_read (prev_regs
, regnum
, prev_buffer
);
1136 this_status
= regcache_cooked_read (this_regs
, regnum
, this_buffer
);
1138 if (this_status
!= prev_status
)
1140 else if (this_status
== REG_VALID
)
1141 return memcmp (prev_buffer
, this_buffer
,
1142 register_size (gdbarch
, regnum
)) != 0;
1147 /* Return a list of register number and value pairs. The valid
1148 arguments expected are: a letter indicating the format in which to
1149 display the registers contents. This can be one of: x
1150 (hexadecimal), d (decimal), N (natural), t (binary), o (octal), r
1151 (raw). After the format argument there can be a sequence of
1152 numbers, indicating which registers to fetch the content of. If
1153 the format is the only argument, a list of all the registers with
1154 their values is returned. */
1157 mi_cmd_data_list_register_values (char *command
, char **argv
, int argc
)
1159 struct ui_out
*uiout
= current_uiout
;
1160 struct frame_info
*frame
;
1161 struct gdbarch
*gdbarch
;
1162 int regnum
, numregs
, format
;
1164 struct cleanup
*list_cleanup
;
1165 int skip_unavailable
= 0;
1171 static const struct mi_opt opts
[] =
1173 {"-skip-unavailable", SKIP_UNAVAILABLE
, 0},
1177 /* Note that the test for a valid register must include checking the
1178 gdbarch_register_name because gdbarch_num_regs may be allocated
1179 for the union of the register sets within a family of related
1180 processors. In this case, some entries of gdbarch_register_name
1181 will change depending upon the particular processor being
1187 int opt
= mi_getopt ("-data-list-register-values", argc
, argv
,
1188 opts
, &oind
, &oarg
);
1192 switch ((enum opt
) opt
)
1194 case SKIP_UNAVAILABLE
:
1195 skip_unavailable
= 1;
1200 if (argc
- oind
< 1)
1201 error (_("-data-list-register-values: Usage: "
1202 "-data-list-register-values [--skip-unavailable] <format>"
1203 " [<regnum1>...<regnumN>]"));
1205 format
= (int) argv
[oind
][0];
1207 frame
= get_selected_frame (NULL
);
1208 gdbarch
= get_frame_arch (frame
);
1209 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1211 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "register-values");
1213 if (argc
- oind
== 1)
1215 /* No args, beside the format: do all the regs. */
1220 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1221 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1224 output_register (frame
, regnum
, format
, skip_unavailable
);
1228 /* Else, list of register #s, just do listed regs. */
1229 for (i
= 1 + oind
; i
< argc
; i
++)
1231 regnum
= atoi (argv
[i
]);
1235 && gdbarch_register_name (gdbarch
, regnum
) != NULL
1236 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
1237 output_register (frame
, regnum
, format
, skip_unavailable
);
1239 error (_("bad register number"));
1241 do_cleanups (list_cleanup
);
1244 /* Output one register REGNUM's contents in the desired FORMAT. If
1245 SKIP_UNAVAILABLE is true, skip the register if it is
1249 output_register (struct frame_info
*frame
, int regnum
, int format
,
1250 int skip_unavailable
)
1252 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1253 struct ui_out
*uiout
= current_uiout
;
1254 struct value
*val
= value_of_register (regnum
, frame
);
1255 struct cleanup
*tuple_cleanup
;
1256 struct value_print_options opts
;
1257 struct ui_file
*stb
;
1259 if (skip_unavailable
&& !value_entirely_available (val
))
1262 tuple_cleanup
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1263 ui_out_field_int (uiout
, "number", regnum
);
1271 stb
= mem_fileopen ();
1272 make_cleanup_ui_file_delete (stb
);
1274 get_formatted_print_options (&opts
, format
);
1276 val_print (value_type (val
),
1277 value_contents_for_printing (val
),
1278 value_embedded_offset (val
), 0,
1279 stb
, 0, val
, &opts
, current_language
);
1280 ui_out_field_stream (uiout
, "value", stb
);
1282 do_cleanups (tuple_cleanup
);
1285 /* Write given values into registers. The registers and values are
1286 given as pairs. The corresponding MI command is
1287 -data-write-register-values <format>
1288 [<regnum1> <value1>...<regnumN> <valueN>] */
1290 mi_cmd_data_write_register_values (char *command
, char **argv
, int argc
)
1292 struct regcache
*regcache
;
1293 struct gdbarch
*gdbarch
;
1296 /* Note that the test for a valid register must include checking the
1297 gdbarch_register_name because gdbarch_num_regs may be allocated
1298 for the union of the register sets within a family of related
1299 processors. In this case, some entries of gdbarch_register_name
1300 will change depending upon the particular processor being
1303 regcache
= get_current_regcache ();
1304 gdbarch
= get_regcache_arch (regcache
);
1305 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1308 error (_("-data-write-register-values: Usage: -data-write-register-"
1309 "values <format> [<regnum1> <value1>...<regnumN> <valueN>]"));
1311 if (!target_has_registers
)
1312 error (_("-data-write-register-values: No registers."));
1315 error (_("-data-write-register-values: No regs and values specified."));
1318 error (_("-data-write-register-values: "
1319 "Regs and vals are not in pairs."));
1321 for (i
= 1; i
< argc
; i
= i
+ 2)
1323 int regnum
= atoi (argv
[i
]);
1325 if (regnum
>= 0 && regnum
< numregs
1326 && gdbarch_register_name (gdbarch
, regnum
)
1327 && *gdbarch_register_name (gdbarch
, regnum
))
1331 /* Get the value as a number. */
1332 value
= parse_and_eval_address (argv
[i
+ 1]);
1334 /* Write it down. */
1335 regcache_cooked_write_signed (regcache
, regnum
, value
);
1338 error (_("bad register number"));
1342 /* Evaluate the value of the argument. The argument is an
1343 expression. If the expression contains spaces it needs to be
1344 included in double quotes. */
1347 mi_cmd_data_evaluate_expression (char *command
, char **argv
, int argc
)
1349 struct expression
*expr
;
1350 struct cleanup
*old_chain
;
1352 struct ui_file
*stb
;
1353 struct value_print_options opts
;
1354 struct ui_out
*uiout
= current_uiout
;
1356 stb
= mem_fileopen ();
1357 old_chain
= make_cleanup_ui_file_delete (stb
);
1360 error (_("-data-evaluate-expression: "
1361 "Usage: -data-evaluate-expression expression"));
1363 expr
= parse_expression (argv
[0]);
1365 make_cleanup (free_current_contents
, &expr
);
1367 val
= evaluate_expression (expr
);
1369 /* Print the result of the expression evaluation. */
1370 get_user_print_options (&opts
);
1372 common_val_print (val
, stb
, 0, &opts
, current_language
);
1374 ui_out_field_stream (uiout
, "value", stb
);
1376 do_cleanups (old_chain
);
1379 /* This is the -data-read-memory command.
1381 ADDR: start address of data to be dumped.
1382 WORD-FORMAT: a char indicating format for the ``word''. See
1384 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
1385 NR_ROW: Number of rows.
1386 NR_COL: The number of colums (words per row).
1387 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
1388 ASCHAR for unprintable characters.
1390 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
1391 displayes them. Returns:
1393 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
1396 The number of bytes read is SIZE*ROW*COL. */
1399 mi_cmd_data_read_memory (char *command
, char **argv
, int argc
)
1401 struct gdbarch
*gdbarch
= get_current_arch ();
1402 struct ui_out
*uiout
= current_uiout
;
1403 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
1405 long total_bytes
, nr_cols
, nr_rows
;
1407 struct type
*word_type
;
1420 static const struct mi_opt opts
[] =
1422 {"o", OFFSET_OPT
, 1},
1428 int opt
= mi_getopt ("-data-read-memory", argc
, argv
, opts
,
1433 switch ((enum opt
) opt
)
1436 offset
= atol (oarg
);
1443 if (argc
< 5 || argc
> 6)
1444 error (_("-data-read-memory: Usage: "
1445 "ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR]."));
1447 /* Extract all the arguments. */
1449 /* Start address of the memory dump. */
1450 addr
= parse_and_eval_address (argv
[0]) + offset
;
1451 /* The format character to use when displaying a memory word. See
1452 the ``x'' command. */
1453 word_format
= argv
[1][0];
1454 /* The size of the memory word. */
1455 word_size
= atol (argv
[2]);
1459 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1463 word_type
= builtin_type (gdbarch
)->builtin_int16
;
1467 word_type
= builtin_type (gdbarch
)->builtin_int32
;
1471 word_type
= builtin_type (gdbarch
)->builtin_int64
;
1475 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1478 /* The number of rows. */
1479 nr_rows
= atol (argv
[3]);
1481 error (_("-data-read-memory: invalid number of rows."));
1483 /* Number of bytes per row. */
1484 nr_cols
= atol (argv
[4]);
1486 error (_("-data-read-memory: invalid number of columns."));
1488 /* The un-printable character when printing ascii. */
1494 /* Create a buffer and read it in. */
1495 total_bytes
= word_size
* nr_rows
* nr_cols
;
1496 mbuf
= xcalloc (total_bytes
, 1);
1497 make_cleanup (xfree
, mbuf
);
1499 /* Dispatch memory reads to the topmost target, not the flattened
1501 nr_bytes
= target_read (current_target
.beneath
,
1502 TARGET_OBJECT_MEMORY
, NULL
, mbuf
,
1505 error (_("Unable to read memory."));
1507 /* Output the header information. */
1508 ui_out_field_core_addr (uiout
, "addr", gdbarch
, addr
);
1509 ui_out_field_int (uiout
, "nr-bytes", nr_bytes
);
1510 ui_out_field_int (uiout
, "total-bytes", total_bytes
);
1511 ui_out_field_core_addr (uiout
, "next-row",
1512 gdbarch
, addr
+ word_size
* nr_cols
);
1513 ui_out_field_core_addr (uiout
, "prev-row",
1514 gdbarch
, addr
- word_size
* nr_cols
);
1515 ui_out_field_core_addr (uiout
, "next-page", gdbarch
, addr
+ total_bytes
);
1516 ui_out_field_core_addr (uiout
, "prev-page", gdbarch
, addr
- total_bytes
);
1518 /* Build the result as a two dimentional table. */
1520 struct ui_file
*stream
;
1521 struct cleanup
*cleanup_stream
;
1525 stream
= mem_fileopen ();
1526 cleanup_stream
= make_cleanup_ui_file_delete (stream
);
1528 make_cleanup_ui_out_list_begin_end (uiout
, "memory");
1529 for (row
= 0, row_byte
= 0;
1531 row
++, row_byte
+= nr_cols
* word_size
)
1535 struct cleanup
*cleanup_tuple
;
1536 struct cleanup
*cleanup_list_data
;
1537 struct value_print_options opts
;
1539 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1540 ui_out_field_core_addr (uiout
, "addr", gdbarch
, addr
+ row_byte
);
1541 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr +
1543 cleanup_list_data
= make_cleanup_ui_out_list_begin_end (uiout
, "data");
1544 get_formatted_print_options (&opts
, word_format
);
1545 for (col
= 0, col_byte
= row_byte
;
1547 col
++, col_byte
+= word_size
)
1549 if (col_byte
+ word_size
> nr_bytes
)
1551 ui_out_field_string (uiout
, NULL
, "N/A");
1555 ui_file_rewind (stream
);
1556 print_scalar_formatted (mbuf
+ col_byte
, word_type
, &opts
,
1557 word_asize
, stream
);
1558 ui_out_field_stream (uiout
, NULL
, stream
);
1561 do_cleanups (cleanup_list_data
);
1566 ui_file_rewind (stream
);
1567 for (byte
= row_byte
;
1568 byte
< row_byte
+ word_size
* nr_cols
; byte
++)
1570 if (byte
>= nr_bytes
)
1571 fputc_unfiltered ('X', stream
);
1572 else if (mbuf
[byte
] < 32 || mbuf
[byte
] > 126)
1573 fputc_unfiltered (aschar
, stream
);
1575 fputc_unfiltered (mbuf
[byte
], stream
);
1577 ui_out_field_stream (uiout
, "ascii", stream
);
1579 do_cleanups (cleanup_tuple
);
1581 do_cleanups (cleanup_stream
);
1583 do_cleanups (cleanups
);
1587 mi_cmd_data_read_memory_bytes (char *command
, char **argv
, int argc
)
1589 struct gdbarch
*gdbarch
= get_current_arch ();
1590 struct ui_out
*uiout
= current_uiout
;
1591 struct cleanup
*cleanups
;
1594 memory_read_result_s
*read_result
;
1596 VEC(memory_read_result_s
) *result
;
1604 static const struct mi_opt opts
[] =
1606 {"o", OFFSET_OPT
, 1},
1612 int opt
= mi_getopt ("-data-read-memory-bytes", argc
, argv
, opts
,
1616 switch ((enum opt
) opt
)
1619 offset
= atol (oarg
);
1627 error (_("Usage: [ -o OFFSET ] ADDR LENGTH."));
1629 addr
= parse_and_eval_address (argv
[0]) + offset
;
1630 length
= atol (argv
[1]);
1632 result
= read_memory_robust (current_target
.beneath
, addr
, length
);
1634 cleanups
= make_cleanup (free_memory_read_result_vector
, result
);
1636 if (VEC_length (memory_read_result_s
, result
) == 0)
1637 error (_("Unable to read memory."));
1639 make_cleanup_ui_out_list_begin_end (uiout
, "memory");
1641 VEC_iterate (memory_read_result_s
, result
, ix
, read_result
);
1644 struct cleanup
*t
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1648 ui_out_field_core_addr (uiout
, "begin", gdbarch
, read_result
->begin
);
1649 ui_out_field_core_addr (uiout
, "offset", gdbarch
, read_result
->begin
1651 ui_out_field_core_addr (uiout
, "end", gdbarch
, read_result
->end
);
1653 data
= xmalloc ((read_result
->end
- read_result
->begin
) * 2 + 1);
1655 for (i
= 0, p
= data
;
1656 i
< (read_result
->end
- read_result
->begin
);
1659 sprintf (p
, "%02x", read_result
->data
[i
]);
1661 ui_out_field_string (uiout
, "contents", data
);
1665 do_cleanups (cleanups
);
1668 /* Implementation of the -data-write_memory command.
1670 COLUMN_OFFSET: optional argument. Must be preceded by '-o'. The
1671 offset from the beginning of the memory grid row where the cell to
1673 ADDR: start address of the row in the memory grid where the memory
1674 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
1675 the location to write to.
1676 FORMAT: a char indicating format for the ``word''. See
1678 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
1679 VALUE: value to be written into the memory address.
1681 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1686 mi_cmd_data_write_memory (char *command
, char **argv
, int argc
)
1688 struct gdbarch
*gdbarch
= get_current_arch ();
1689 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1692 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1693 enough when using a compiler other than GCC. */
1696 struct cleanup
*old_chain
;
1704 static const struct mi_opt opts
[] =
1706 {"o", OFFSET_OPT
, 1},
1712 int opt
= mi_getopt ("-data-write-memory", argc
, argv
, opts
,
1717 switch ((enum opt
) opt
)
1720 offset
= atol (oarg
);
1728 error (_("-data-write-memory: Usage: "
1729 "[-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE."));
1731 /* Extract all the arguments. */
1732 /* Start address of the memory dump. */
1733 addr
= parse_and_eval_address (argv
[0]);
1734 /* The size of the memory word. */
1735 word_size
= atol (argv
[2]);
1737 /* Calculate the real address of the write destination. */
1738 addr
+= (offset
* word_size
);
1740 /* Get the value as a number. */
1741 value
= parse_and_eval_address (argv
[3]);
1742 /* Get the value into an array. */
1743 buffer
= xmalloc (word_size
);
1744 old_chain
= make_cleanup (xfree
, buffer
);
1745 store_signed_integer (buffer
, word_size
, byte_order
, value
);
1746 /* Write it down to memory. */
1747 write_memory_with_notification (addr
, buffer
, word_size
);
1748 /* Free the buffer. */
1749 do_cleanups (old_chain
);
1752 /* Implementation of the -data-write-memory-bytes command.
1755 DATA: string of bytes to write at that address
1756 COUNT: number of bytes to be filled (decimal integer). */
1759 mi_cmd_data_write_memory_bytes (char *command
, char **argv
, int argc
)
1765 size_t len
, i
, steps
, remainder
;
1767 struct cleanup
*back_to
;
1769 if (argc
!= 2 && argc
!= 3)
1770 error (_("Usage: ADDR DATA [COUNT]."));
1772 addr
= parse_and_eval_address (argv
[0]);
1774 if (strlen (cdata
) % 2)
1775 error (_("Hex-encoded '%s' must have an even number of characters."),
1778 len
= strlen (cdata
)/2;
1780 count
= strtoul (argv
[2], NULL
, 10);
1784 databuf
= xmalloc (len
* sizeof (gdb_byte
));
1785 back_to
= make_cleanup (xfree
, databuf
);
1787 for (i
= 0; i
< len
; ++i
)
1790 if (sscanf (cdata
+ i
* 2, "%02x", &x
) != 1)
1791 error (_("Invalid argument"));
1792 databuf
[i
] = (gdb_byte
) x
;
1797 /* Pattern is made of less bytes than count:
1798 repeat pattern to fill memory. */
1799 data
= xmalloc (count
);
1800 make_cleanup (xfree
, data
);
1802 steps
= count
/ len
;
1803 remainder
= count
% len
;
1804 for (j
= 0; j
< steps
; j
++)
1805 memcpy (data
+ j
* len
, databuf
, len
);
1808 memcpy (data
+ steps
* len
, databuf
, remainder
);
1812 /* Pattern is longer than or equal to count:
1813 just copy count bytes. */
1817 write_memory_with_notification (addr
, data
, count
);
1819 do_cleanups (back_to
);
1823 mi_cmd_enable_timings (char *command
, char **argv
, int argc
)
1829 if (strcmp (argv
[0], "yes") == 0)
1831 else if (strcmp (argv
[0], "no") == 0)
1842 error (_("-enable-timings: Usage: %s {yes|no}"), command
);
1846 mi_cmd_list_features (char *command
, char **argv
, int argc
)
1850 struct cleanup
*cleanup
= NULL
;
1851 struct ui_out
*uiout
= current_uiout
;
1853 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "features");
1854 ui_out_field_string (uiout
, NULL
, "frozen-varobjs");
1855 ui_out_field_string (uiout
, NULL
, "pending-breakpoints");
1856 ui_out_field_string (uiout
, NULL
, "thread-info");
1857 ui_out_field_string (uiout
, NULL
, "data-read-memory-bytes");
1858 ui_out_field_string (uiout
, NULL
, "breakpoint-notifications");
1859 ui_out_field_string (uiout
, NULL
, "ada-task-info");
1860 ui_out_field_string (uiout
, NULL
, "language-option");
1861 ui_out_field_string (uiout
, NULL
, "info-gdb-mi-command");
1862 ui_out_field_string (uiout
, NULL
, "undefined-command-error-code");
1863 ui_out_field_string (uiout
, NULL
, "exec-run-start-option");
1865 if (ext_lang_initialized_p (get_ext_lang_defn (EXT_LANG_PYTHON
)))
1866 ui_out_field_string (uiout
, NULL
, "python");
1868 do_cleanups (cleanup
);
1872 error (_("-list-features should be passed no arguments"));
1876 mi_cmd_list_target_features (char *command
, char **argv
, int argc
)
1880 struct cleanup
*cleanup
= NULL
;
1881 struct ui_out
*uiout
= current_uiout
;
1883 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "features");
1885 ui_out_field_string (uiout
, NULL
, "async");
1886 if (target_can_execute_reverse
)
1887 ui_out_field_string (uiout
, NULL
, "reverse");
1888 do_cleanups (cleanup
);
1892 error (_("-list-target-features should be passed no arguments"));
1896 mi_cmd_add_inferior (char *command
, char **argv
, int argc
)
1898 struct inferior
*inf
;
1901 error (_("-add-inferior should be passed no arguments"));
1903 inf
= add_inferior_with_spaces ();
1905 ui_out_field_fmt (current_uiout
, "inferior", "i%d", inf
->num
);
1908 /* Callback used to find the first inferior other than the current
1912 get_other_inferior (struct inferior
*inf
, void *arg
)
1914 if (inf
== current_inferior ())
1921 mi_cmd_remove_inferior (char *command
, char **argv
, int argc
)
1924 struct inferior
*inf
;
1927 error (_("-remove-inferior should be passed a single argument"));
1929 if (sscanf (argv
[0], "i%d", &id
) != 1)
1930 error (_("the thread group id is syntactically invalid"));
1932 inf
= find_inferior_id (id
);
1934 error (_("the specified thread group does not exist"));
1937 error (_("cannot remove an active inferior"));
1939 if (inf
== current_inferior ())
1941 struct thread_info
*tp
= 0;
1942 struct inferior
*new_inferior
1943 = iterate_over_inferiors (get_other_inferior
, NULL
);
1945 if (new_inferior
== NULL
)
1946 error (_("Cannot remove last inferior"));
1948 set_current_inferior (new_inferior
);
1949 if (new_inferior
->pid
!= 0)
1950 tp
= any_thread_of_process (new_inferior
->pid
);
1951 switch_to_thread (tp
? tp
->ptid
: null_ptid
);
1952 set_current_program_space (new_inferior
->pspace
);
1955 delete_inferior_1 (inf
, 1 /* silent */);
1960 /* Execute a command within a safe environment.
1961 Return <0 for error; >=0 for ok.
1963 args->action will tell mi_execute_command what action
1964 to perfrom after the given command has executed (display/suppress
1965 prompt, display error). */
1968 captured_mi_execute_command (struct ui_out
*uiout
, struct mi_parse
*context
)
1970 struct cleanup
*cleanup
;
1973 current_command_ts
= context
->cmd_start
;
1975 current_token
= xstrdup (context
->token
);
1976 cleanup
= make_cleanup (free_current_contents
, ¤t_token
);
1978 running_result_record_printed
= 0;
1980 switch (context
->op
)
1983 /* A MI command was read from the input stream. */
1985 /* FIXME: gdb_???? */
1986 fprintf_unfiltered (raw_stdout
, " token=`%s' command=`%s' args=`%s'\n",
1987 context
->token
, context
->command
, context
->args
);
1989 mi_cmd_execute (context
);
1991 /* Print the result if there were no errors.
1993 Remember that on the way out of executing a command, you have
1994 to directly use the mi_interp's uiout, since the command
1995 could have reset the interpreter, in which case the current
1996 uiout will most likely crash in the mi_out_* routines. */
1997 if (!running_result_record_printed
)
1999 fputs_unfiltered (context
->token
, raw_stdout
);
2000 /* There's no particularly good reason why target-connect results
2001 in not ^done. Should kill ^connected for MI3. */
2002 fputs_unfiltered (strcmp (context
->command
, "target-select") == 0
2003 ? "^connected" : "^done", raw_stdout
);
2004 mi_out_put (uiout
, raw_stdout
);
2005 mi_out_rewind (uiout
);
2006 mi_print_timing_maybe ();
2007 fputs_unfiltered ("\n", raw_stdout
);
2010 /* The command does not want anything to be printed. In that
2011 case, the command probably should not have written anything
2012 to uiout, but in case it has written something, discard it. */
2013 mi_out_rewind (uiout
);
2020 /* A CLI command was read from the input stream. */
2021 /* This "feature" will be removed as soon as we have a
2022 complete set of mi commands. */
2023 /* Echo the command on the console. */
2024 fprintf_unfiltered (gdb_stdlog
, "%s\n", context
->command
);
2025 /* Call the "console" interpreter. */
2026 argv
[0] = "console";
2027 argv
[1] = context
->command
;
2028 mi_cmd_interpreter_exec ("-interpreter-exec", argv
, 2);
2030 /* If we changed interpreters, DON'T print out anything. */
2031 if (current_interp_named_p (INTERP_MI
)
2032 || current_interp_named_p (INTERP_MI1
)
2033 || current_interp_named_p (INTERP_MI2
)
2034 || current_interp_named_p (INTERP_MI3
))
2036 if (!running_result_record_printed
)
2038 fputs_unfiltered (context
->token
, raw_stdout
);
2039 fputs_unfiltered ("^done", raw_stdout
);
2040 mi_out_put (uiout
, raw_stdout
);
2041 mi_out_rewind (uiout
);
2042 mi_print_timing_maybe ();
2043 fputs_unfiltered ("\n", raw_stdout
);
2046 mi_out_rewind (uiout
);
2052 do_cleanups (cleanup
);
2055 /* Print a gdb exception to the MI output stream. */
2058 mi_print_exception (const char *token
, struct gdb_exception exception
)
2060 fputs_unfiltered (token
, raw_stdout
);
2061 fputs_unfiltered ("^error,msg=\"", raw_stdout
);
2062 if (exception
.message
== NULL
)
2063 fputs_unfiltered ("unknown error", raw_stdout
);
2065 fputstr_unfiltered (exception
.message
, '"', raw_stdout
);
2066 fputs_unfiltered ("\"", raw_stdout
);
2068 switch (exception
.error
)
2070 case UNDEFINED_COMMAND_ERROR
:
2071 fputs_unfiltered (",code=\"undefined-command\"", raw_stdout
);
2075 fputs_unfiltered ("\n", raw_stdout
);
2079 mi_execute_command (const char *cmd
, int from_tty
)
2082 struct mi_parse
*command
= NULL
;
2083 volatile struct gdb_exception exception
;
2085 /* This is to handle EOF (^D). We just quit gdb. */
2086 /* FIXME: we should call some API function here. */
2088 quit_force (NULL
, from_tty
);
2090 target_log_command (cmd
);
2092 TRY_CATCH (exception
, RETURN_MASK_ALL
)
2094 command
= mi_parse (cmd
, &token
);
2096 if (exception
.reason
< 0)
2098 mi_print_exception (token
, exception
);
2103 volatile struct gdb_exception result
;
2104 ptid_t previous_ptid
= inferior_ptid
;
2106 command
->token
= token
;
2110 command
->cmd_start
= (struct mi_timestamp
*)
2111 xmalloc (sizeof (struct mi_timestamp
));
2112 timestamp (command
->cmd_start
);
2115 TRY_CATCH (result
, RETURN_MASK_ALL
)
2117 captured_mi_execute_command (current_uiout
, command
);
2119 if (result
.reason
< 0)
2121 /* The command execution failed and error() was called
2123 mi_print_exception (command
->token
, result
);
2124 mi_out_rewind (current_uiout
);
2127 bpstat_do_actions ();
2129 if (/* The notifications are only output when the top-level
2130 interpreter (specified on the command line) is MI. */
2131 ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ()))
2132 /* Don't try report anything if there are no threads --
2133 the program is dead. */
2134 && thread_count () != 0
2135 /* -thread-select explicitly changes thread. If frontend uses that
2136 internally, we don't want to emit =thread-selected, since
2137 =thread-selected is supposed to indicate user's intentions. */
2138 && strcmp (command
->command
, "thread-select") != 0)
2140 struct mi_interp
*mi
= top_level_interpreter_data ();
2141 int report_change
= 0;
2143 if (command
->thread
== -1)
2145 report_change
= (!ptid_equal (previous_ptid
, null_ptid
)
2146 && !ptid_equal (inferior_ptid
, previous_ptid
)
2147 && !ptid_equal (inferior_ptid
, null_ptid
));
2149 else if (!ptid_equal (inferior_ptid
, null_ptid
))
2151 struct thread_info
*ti
= inferior_thread ();
2153 report_change
= (ti
->num
!= command
->thread
);
2158 struct thread_info
*ti
= inferior_thread ();
2160 target_terminal_ours ();
2161 fprintf_unfiltered (mi
->event_channel
,
2162 "thread-selected,id=\"%d\"",
2164 gdb_flush (mi
->event_channel
);
2168 mi_parse_free (command
);
2173 mi_cmd_execute (struct mi_parse
*parse
)
2175 struct cleanup
*cleanup
;
2176 enum language saved_language
;
2178 cleanup
= prepare_execute_command ();
2180 if (parse
->all
&& parse
->thread_group
!= -1)
2181 error (_("Cannot specify --thread-group together with --all"));
2183 if (parse
->all
&& parse
->thread
!= -1)
2184 error (_("Cannot specify --thread together with --all"));
2186 if (parse
->thread_group
!= -1 && parse
->thread
!= -1)
2187 error (_("Cannot specify --thread together with --thread-group"));
2189 if (parse
->frame
!= -1 && parse
->thread
== -1)
2190 error (_("Cannot specify --frame without --thread"));
2192 if (parse
->thread_group
!= -1)
2194 struct inferior
*inf
= find_inferior_id (parse
->thread_group
);
2195 struct thread_info
*tp
= 0;
2198 error (_("Invalid thread group for the --thread-group option"));
2200 set_current_inferior (inf
);
2201 /* This behaviour means that if --thread-group option identifies
2202 an inferior with multiple threads, then a random one will be
2203 picked. This is not a problem -- frontend should always
2204 provide --thread if it wishes to operate on a specific
2207 tp
= any_live_thread_of_process (inf
->pid
);
2208 switch_to_thread (tp
? tp
->ptid
: null_ptid
);
2209 set_current_program_space (inf
->pspace
);
2212 if (parse
->thread
!= -1)
2214 struct thread_info
*tp
= find_thread_id (parse
->thread
);
2217 error (_("Invalid thread id: %d"), parse
->thread
);
2219 if (is_exited (tp
->ptid
))
2220 error (_("Thread id: %d has terminated"), parse
->thread
);
2222 switch_to_thread (tp
->ptid
);
2225 if (parse
->frame
!= -1)
2227 struct frame_info
*fid
;
2228 int frame
= parse
->frame
;
2230 fid
= find_relative_frame (get_current_frame (), &frame
);
2232 /* find_relative_frame was successful */
2235 error (_("Invalid frame id: %d"), frame
);
2238 if (parse
->language
!= language_unknown
)
2240 make_cleanup_restore_current_language ();
2241 set_language (parse
->language
);
2244 current_context
= parse
;
2246 if (parse
->cmd
->suppress_notification
!= NULL
)
2248 make_cleanup_restore_integer (parse
->cmd
->suppress_notification
);
2249 *parse
->cmd
->suppress_notification
= 1;
2252 if (parse
->cmd
->argv_func
!= NULL
)
2254 parse
->cmd
->argv_func (parse
->command
, parse
->argv
, parse
->argc
);
2256 else if (parse
->cmd
->cli
.cmd
!= 0)
2258 /* FIXME: DELETE THIS. */
2259 /* The operation is still implemented by a cli command. */
2260 /* Must be a synchronous one. */
2261 mi_execute_cli_command (parse
->cmd
->cli
.cmd
, parse
->cmd
->cli
.args_p
,
2266 /* FIXME: DELETE THIS. */
2267 struct ui_file
*stb
;
2269 stb
= mem_fileopen ();
2271 fputs_unfiltered ("Undefined mi command: ", stb
);
2272 fputstr_unfiltered (parse
->command
, '"', stb
);
2273 fputs_unfiltered (" (missing implementation)", stb
);
2275 make_cleanup_ui_file_delete (stb
);
2278 do_cleanups (cleanup
);
2281 /* FIXME: This is just a hack so we can get some extra commands going.
2282 We don't want to channel things through the CLI, but call libgdb directly.
2283 Use only for synchronous commands. */
2286 mi_execute_cli_command (const char *cmd
, int args_p
, const char *args
)
2290 struct cleanup
*old_cleanups
;
2294 run
= xstrprintf ("%s %s", cmd
, args
);
2296 run
= xstrdup (cmd
);
2298 /* FIXME: gdb_???? */
2299 fprintf_unfiltered (gdb_stdout
, "cli=%s run=%s\n",
2301 old_cleanups
= make_cleanup (xfree
, run
);
2302 execute_command (run
, 0 /* from_tty */ );
2303 do_cleanups (old_cleanups
);
2309 mi_execute_async_cli_command (char *cli_command
, char **argv
, int argc
)
2311 struct cleanup
*old_cleanups
;
2315 run
= xstrprintf ("%s %s&", cli_command
, argc
? *argv
: "");
2317 run
= xstrprintf ("%s %s", cli_command
, argc
? *argv
: "");
2318 old_cleanups
= make_cleanup (xfree
, run
);
2320 execute_command (run
, 0 /* from_tty */ );
2322 /* Do this before doing any printing. It would appear that some
2323 print code leaves garbage around in the buffer. */
2324 do_cleanups (old_cleanups
);
2328 mi_load_progress (const char *section_name
,
2329 unsigned long sent_so_far
,
2330 unsigned long total_section
,
2331 unsigned long total_sent
,
2332 unsigned long grand_total
)
2334 struct timeval time_now
, delta
, update_threshold
;
2335 static struct timeval last_update
;
2336 static char *previous_sect_name
= NULL
;
2338 struct ui_out
*saved_uiout
;
2339 struct ui_out
*uiout
;
2341 /* This function is called through deprecated_show_load_progress
2342 which means uiout may not be correct. Fix it for the duration
2343 of this function. */
2344 saved_uiout
= current_uiout
;
2346 if (current_interp_named_p (INTERP_MI
)
2347 || current_interp_named_p (INTERP_MI2
))
2348 current_uiout
= mi_out_new (2);
2349 else if (current_interp_named_p (INTERP_MI1
))
2350 current_uiout
= mi_out_new (1);
2351 else if (current_interp_named_p (INTERP_MI3
))
2352 current_uiout
= mi_out_new (3);
2356 uiout
= current_uiout
;
2358 update_threshold
.tv_sec
= 0;
2359 update_threshold
.tv_usec
= 500000;
2360 gettimeofday (&time_now
, NULL
);
2362 delta
.tv_usec
= time_now
.tv_usec
- last_update
.tv_usec
;
2363 delta
.tv_sec
= time_now
.tv_sec
- last_update
.tv_sec
;
2365 if (delta
.tv_usec
< 0)
2368 delta
.tv_usec
+= 1000000L;
2371 new_section
= (previous_sect_name
?
2372 strcmp (previous_sect_name
, section_name
) : 1);
2375 struct cleanup
*cleanup_tuple
;
2377 xfree (previous_sect_name
);
2378 previous_sect_name
= xstrdup (section_name
);
2381 fputs_unfiltered (current_token
, raw_stdout
);
2382 fputs_unfiltered ("+download", raw_stdout
);
2383 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2384 ui_out_field_string (uiout
, "section", section_name
);
2385 ui_out_field_int (uiout
, "section-size", total_section
);
2386 ui_out_field_int (uiout
, "total-size", grand_total
);
2387 do_cleanups (cleanup_tuple
);
2388 mi_out_put (uiout
, raw_stdout
);
2389 fputs_unfiltered ("\n", raw_stdout
);
2390 gdb_flush (raw_stdout
);
2393 if (delta
.tv_sec
>= update_threshold
.tv_sec
&&
2394 delta
.tv_usec
>= update_threshold
.tv_usec
)
2396 struct cleanup
*cleanup_tuple
;
2398 last_update
.tv_sec
= time_now
.tv_sec
;
2399 last_update
.tv_usec
= time_now
.tv_usec
;
2401 fputs_unfiltered (current_token
, raw_stdout
);
2402 fputs_unfiltered ("+download", raw_stdout
);
2403 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2404 ui_out_field_string (uiout
, "section", section_name
);
2405 ui_out_field_int (uiout
, "section-sent", sent_so_far
);
2406 ui_out_field_int (uiout
, "section-size", total_section
);
2407 ui_out_field_int (uiout
, "total-sent", total_sent
);
2408 ui_out_field_int (uiout
, "total-size", grand_total
);
2409 do_cleanups (cleanup_tuple
);
2410 mi_out_put (uiout
, raw_stdout
);
2411 fputs_unfiltered ("\n", raw_stdout
);
2412 gdb_flush (raw_stdout
);
2416 current_uiout
= saved_uiout
;
2420 timestamp (struct mi_timestamp
*tv
)
2422 gettimeofday (&tv
->wallclock
, NULL
);
2423 #ifdef HAVE_GETRUSAGE
2424 getrusage (RUSAGE_SELF
, &rusage
);
2425 tv
->utime
.tv_sec
= rusage
.ru_utime
.tv_sec
;
2426 tv
->utime
.tv_usec
= rusage
.ru_utime
.tv_usec
;
2427 tv
->stime
.tv_sec
= rusage
.ru_stime
.tv_sec
;
2428 tv
->stime
.tv_usec
= rusage
.ru_stime
.tv_usec
;
2431 long usec
= get_run_time ();
2433 tv
->utime
.tv_sec
= usec
/1000000L;
2434 tv
->utime
.tv_usec
= usec
- 1000000L*tv
->utime
.tv_sec
;
2435 tv
->stime
.tv_sec
= 0;
2436 tv
->stime
.tv_usec
= 0;
2442 print_diff_now (struct mi_timestamp
*start
)
2444 struct mi_timestamp now
;
2447 print_diff (start
, &now
);
2451 mi_print_timing_maybe (void)
2453 /* If the command is -enable-timing then do_timings may be true
2454 whilst current_command_ts is not initialized. */
2455 if (do_timings
&& current_command_ts
)
2456 print_diff_now (current_command_ts
);
2460 timeval_diff (struct timeval start
, struct timeval end
)
2462 return ((end
.tv_sec
- start
.tv_sec
) * 1000000L)
2463 + (end
.tv_usec
- start
.tv_usec
);
2467 print_diff (struct mi_timestamp
*start
, struct mi_timestamp
*end
)
2471 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
2472 timeval_diff (start
->wallclock
, end
->wallclock
) / 1000000.0,
2473 timeval_diff (start
->utime
, end
->utime
) / 1000000.0,
2474 timeval_diff (start
->stime
, end
->stime
) / 1000000.0);
2478 mi_cmd_trace_define_variable (char *command
, char **argv
, int argc
)
2480 struct expression
*expr
;
2481 LONGEST initval
= 0;
2482 struct trace_state_variable
*tsv
;
2485 if (argc
!= 1 && argc
!= 2)
2486 error (_("Usage: -trace-define-variable VARIABLE [VALUE]"));
2490 error (_("Name of trace variable should start with '$'"));
2492 validate_trace_state_variable_name (name
);
2494 tsv
= find_trace_state_variable (name
);
2496 tsv
= create_trace_state_variable (name
);
2499 initval
= value_as_long (parse_and_eval (argv
[1]));
2501 tsv
->initial_value
= initval
;
2505 mi_cmd_trace_list_variables (char *command
, char **argv
, int argc
)
2508 error (_("-trace-list-variables: no arguments allowed"));
2510 tvariables_info_1 ();
2514 mi_cmd_trace_find (char *command
, char **argv
, int argc
)
2519 error (_("trace selection mode is required"));
2523 if (strcmp (mode
, "none") == 0)
2525 tfind_1 (tfind_number
, -1, 0, 0, 0);
2529 check_trace_running (current_trace_status ());
2531 if (strcmp (mode
, "frame-number") == 0)
2534 error (_("frame number is required"));
2535 tfind_1 (tfind_number
, atoi (argv
[1]), 0, 0, 0);
2537 else if (strcmp (mode
, "tracepoint-number") == 0)
2540 error (_("tracepoint number is required"));
2541 tfind_1 (tfind_tp
, atoi (argv
[1]), 0, 0, 0);
2543 else if (strcmp (mode
, "pc") == 0)
2546 error (_("PC is required"));
2547 tfind_1 (tfind_pc
, 0, parse_and_eval_address (argv
[1]), 0, 0);
2549 else if (strcmp (mode
, "pc-inside-range") == 0)
2552 error (_("Start and end PC are required"));
2553 tfind_1 (tfind_range
, 0, parse_and_eval_address (argv
[1]),
2554 parse_and_eval_address (argv
[2]), 0);
2556 else if (strcmp (mode
, "pc-outside-range") == 0)
2559 error (_("Start and end PC are required"));
2560 tfind_1 (tfind_outside
, 0, parse_and_eval_address (argv
[1]),
2561 parse_and_eval_address (argv
[2]), 0);
2563 else if (strcmp (mode
, "line") == 0)
2565 struct symtabs_and_lines sals
;
2566 struct symtab_and_line sal
;
2567 static CORE_ADDR start_pc
, end_pc
;
2568 struct cleanup
*back_to
;
2571 error (_("Line is required"));
2573 sals
= decode_line_with_current_source (argv
[1],
2574 DECODE_LINE_FUNFIRSTLINE
);
2575 back_to
= make_cleanup (xfree
, sals
.sals
);
2579 if (sal
.symtab
== 0)
2580 error (_("Could not find the specified line"));
2582 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2583 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, 0);
2585 error (_("Could not find the specified line"));
2587 do_cleanups (back_to
);
2590 error (_("Invalid mode '%s'"), mode
);
2592 if (has_stack_frames () || get_traceframe_number () >= 0)
2593 print_stack_frame (get_selected_frame (NULL
), 1, LOC_AND_ADDRESS
, 1);
2597 mi_cmd_trace_save (char *command
, char **argv
, int argc
)
2599 int target_saves
= 0;
2600 int generate_ctf
= 0;
2607 TARGET_SAVE_OPT
, CTF_OPT
2609 static const struct mi_opt opts
[] =
2611 {"r", TARGET_SAVE_OPT
, 0},
2612 {"ctf", CTF_OPT
, 0},
2618 int opt
= mi_getopt ("-trace-save", argc
, argv
, opts
,
2623 switch ((enum opt
) opt
)
2625 case TARGET_SAVE_OPT
:
2633 filename
= argv
[oind
];
2636 trace_save_ctf (filename
, target_saves
);
2638 trace_save_tfile (filename
, target_saves
);
2642 mi_cmd_trace_start (char *command
, char **argv
, int argc
)
2644 start_tracing (NULL
);
2648 mi_cmd_trace_status (char *command
, char **argv
, int argc
)
2650 trace_status_mi (0);
2654 mi_cmd_trace_stop (char *command
, char **argv
, int argc
)
2656 stop_tracing (NULL
);
2657 trace_status_mi (1);
2660 /* Implement the "-ada-task-info" command. */
2663 mi_cmd_ada_task_info (char *command
, char **argv
, int argc
)
2665 if (argc
!= 0 && argc
!= 1)
2666 error (_("Invalid MI command"));
2668 print_ada_task_info (current_uiout
, argv
[0], current_inferior ());
2671 /* Print EXPRESSION according to VALUES. */
2674 print_variable_or_computed (char *expression
, enum print_values values
)
2676 struct expression
*expr
;
2677 struct cleanup
*old_chain
;
2679 struct ui_file
*stb
;
2680 struct value_print_options opts
;
2682 struct ui_out
*uiout
= current_uiout
;
2684 stb
= mem_fileopen ();
2685 old_chain
= make_cleanup_ui_file_delete (stb
);
2687 expr
= parse_expression (expression
);
2689 make_cleanup (free_current_contents
, &expr
);
2691 if (values
== PRINT_SIMPLE_VALUES
)
2692 val
= evaluate_type (expr
);
2694 val
= evaluate_expression (expr
);
2696 if (values
!= PRINT_NO_VALUES
)
2697 make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2698 ui_out_field_string (uiout
, "name", expression
);
2702 case PRINT_SIMPLE_VALUES
:
2703 type
= check_typedef (value_type (val
));
2704 type_print (value_type (val
), "", stb
, -1);
2705 ui_out_field_stream (uiout
, "type", stb
);
2706 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
2707 && TYPE_CODE (type
) != TYPE_CODE_STRUCT
2708 && TYPE_CODE (type
) != TYPE_CODE_UNION
)
2710 struct value_print_options opts
;
2712 get_no_prettyformat_print_options (&opts
);
2714 common_val_print (val
, stb
, 0, &opts
, current_language
);
2715 ui_out_field_stream (uiout
, "value", stb
);
2718 case PRINT_ALL_VALUES
:
2720 struct value_print_options opts
;
2722 get_no_prettyformat_print_options (&opts
);
2724 common_val_print (val
, stb
, 0, &opts
, current_language
);
2725 ui_out_field_stream (uiout
, "value", stb
);
2730 do_cleanups (old_chain
);
2733 /* Implement the "-trace-frame-collected" command. */
2736 mi_cmd_trace_frame_collected (char *command
, char **argv
, int argc
)
2738 struct cleanup
*old_chain
;
2739 struct bp_location
*tloc
;
2741 struct collection_list
*clist
;
2742 struct collection_list tracepoint_list
, stepping_list
;
2743 struct traceframe_info
*tinfo
;
2745 int var_print_values
= PRINT_ALL_VALUES
;
2746 int comp_print_values
= PRINT_ALL_VALUES
;
2747 int registers_format
= 'x';
2748 int memory_contents
= 0;
2749 struct ui_out
*uiout
= current_uiout
;
2757 static const struct mi_opt opts
[] =
2759 {"-var-print-values", VAR_PRINT_VALUES
, 1},
2760 {"-comp-print-values", COMP_PRINT_VALUES
, 1},
2761 {"-registers-format", REGISTERS_FORMAT
, 1},
2762 {"-memory-contents", MEMORY_CONTENTS
, 0},
2769 int opt
= mi_getopt ("-trace-frame-collected", argc
, argv
, opts
,
2773 switch ((enum opt
) opt
)
2775 case VAR_PRINT_VALUES
:
2776 var_print_values
= mi_parse_print_values (oarg
);
2778 case COMP_PRINT_VALUES
:
2779 comp_print_values
= mi_parse_print_values (oarg
);
2781 case REGISTERS_FORMAT
:
2782 registers_format
= oarg
[0];
2783 case MEMORY_CONTENTS
:
2784 memory_contents
= 1;
2790 error (_("Usage: -trace-frame-collected "
2791 "[--var-print-values PRINT_VALUES] "
2792 "[--comp-print-values PRINT_VALUES] "
2793 "[--registers-format FORMAT]"
2794 "[--memory-contents]"));
2796 /* This throws an error is not inspecting a trace frame. */
2797 tloc
= get_traceframe_location (&stepping_frame
);
2799 /* This command only makes sense for the current frame, not the
2801 old_chain
= make_cleanup_restore_current_thread ();
2802 select_frame (get_current_frame ());
2804 encode_actions_and_make_cleanup (tloc
, &tracepoint_list
,
2808 clist
= &stepping_list
;
2810 clist
= &tracepoint_list
;
2812 tinfo
= get_traceframe_info ();
2814 /* Explicitly wholly collected variables. */
2816 struct cleanup
*list_cleanup
;
2820 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
,
2821 "explicit-variables");
2822 for (i
= 0; VEC_iterate (char_ptr
, clist
->wholly_collected
, i
, p
); i
++)
2823 print_variable_or_computed (p
, var_print_values
);
2824 do_cleanups (list_cleanup
);
2827 /* Computed expressions. */
2829 struct cleanup
*list_cleanup
;
2834 = make_cleanup_ui_out_list_begin_end (uiout
,
2835 "computed-expressions");
2836 for (i
= 0; VEC_iterate (char_ptr
, clist
->computed
, i
, p
); i
++)
2837 print_variable_or_computed (p
, comp_print_values
);
2838 do_cleanups (list_cleanup
);
2841 /* Registers. Given pseudo-registers, and that some architectures
2842 (like MIPS) actually hide the raw registers, we don't go through
2843 the trace frame info, but instead consult the register cache for
2844 register availability. */
2846 struct cleanup
*list_cleanup
;
2847 struct frame_info
*frame
;
2848 struct gdbarch
*gdbarch
;
2852 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "registers");
2854 frame
= get_selected_frame (NULL
);
2855 gdbarch
= get_frame_arch (frame
);
2856 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
2858 for (regnum
= 0; regnum
< numregs
; regnum
++)
2860 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
2861 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
2864 output_register (frame
, regnum
, registers_format
, 1);
2867 do_cleanups (list_cleanup
);
2870 /* Trace state variables. */
2872 struct cleanup
*list_cleanup
;
2877 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "tvars");
2880 make_cleanup (free_current_contents
, &tsvname
);
2882 for (i
= 0; VEC_iterate (int, tinfo
->tvars
, i
, tvar
); i
++)
2884 struct cleanup
*cleanup_child
;
2885 struct trace_state_variable
*tsv
;
2887 tsv
= find_trace_state_variable_by_number (tvar
);
2889 cleanup_child
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2893 tsvname
= xrealloc (tsvname
, strlen (tsv
->name
) + 2);
2895 strcpy (tsvname
+ 1, tsv
->name
);
2896 ui_out_field_string (uiout
, "name", tsvname
);
2898 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
2900 ui_out_field_int (uiout
, "current", tsv
->value
);
2904 ui_out_field_skip (uiout
, "name");
2905 ui_out_field_skip (uiout
, "current");
2908 do_cleanups (cleanup_child
);
2911 do_cleanups (list_cleanup
);
2916 struct cleanup
*list_cleanup
;
2917 VEC(mem_range_s
) *available_memory
= NULL
;
2918 struct mem_range
*r
;
2921 traceframe_available_memory (&available_memory
, 0, ULONGEST_MAX
);
2922 make_cleanup (VEC_cleanup(mem_range_s
), &available_memory
);
2924 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "memory");
2926 for (i
= 0; VEC_iterate (mem_range_s
, available_memory
, i
, r
); i
++)
2928 struct cleanup
*cleanup_child
;
2930 struct gdbarch
*gdbarch
= target_gdbarch ();
2932 cleanup_child
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2934 ui_out_field_core_addr (uiout
, "address", gdbarch
, r
->start
);
2935 ui_out_field_int (uiout
, "length", r
->length
);
2937 data
= xmalloc (r
->length
);
2938 make_cleanup (xfree
, data
);
2940 if (memory_contents
)
2942 if (target_read_memory (r
->start
, data
, r
->length
) == 0)
2947 data_str
= xmalloc (r
->length
* 2 + 1);
2948 make_cleanup (xfree
, data_str
);
2950 for (m
= 0, p
= data_str
; m
< r
->length
; ++m
, p
+= 2)
2951 sprintf (p
, "%02x", data
[m
]);
2952 ui_out_field_string (uiout
, "contents", data_str
);
2955 ui_out_field_skip (uiout
, "contents");
2957 do_cleanups (cleanup_child
);
2960 do_cleanups (list_cleanup
);
2963 do_cleanups (old_chain
);
2967 _initialize_mi_main (void)
2969 struct cmd_list_element
*c
;
2971 add_setshow_boolean_cmd ("mi-async", class_run
,
2973 Set whether MI asynchronous mode is enabled."), _("\
2974 Show whether MI asynchronous mode is enabled."), _("\
2975 Tells GDB whether MI should be in asynchronous mode."),
2976 set_mi_async_command
,
2977 show_mi_async_command
,
2981 /* Alias old "target-async" to "mi-async". */
2982 c
= add_alias_cmd ("target-async", "mi-async", class_run
, 0, &setlist
);
2983 deprecate_cmd (c
, "set mi-async");
2984 c
= add_alias_cmd ("target-async", "mi-async", class_run
, 0, &showlist
);
2985 deprecate_cmd (c
, "show mi-async");