3 Copyright (C) 2000-2016 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"
58 #include "gdb_sys_time.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
);
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";
418 struct target_ops
*run_target
= find_run_target ();
419 int async_p
= mi_async
&& run_target
->to_can_async_p (run_target
);
423 if (inf
->pid
!= ptid_get_pid (inferior_ptid
))
425 struct thread_info
*tp
;
427 tp
= any_thread_of_process (inf
->pid
);
429 error (_("Inferior has no threads."));
431 switch_to_thread (tp
->ptid
);
436 set_current_inferior (inf
);
437 switch_to_thread (null_ptid
);
438 set_current_program_space (inf
->pspace
);
440 mi_execute_cli_command (run_cmd
, async_p
,
441 async_p
? "&" : NULL
);
446 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";
493 struct target_ops
*run_target
= find_run_target ();
494 int async_p
= mi_async
&& run_target
->to_can_async_p (run_target
);
496 mi_execute_cli_command (run_cmd
, async_p
,
497 async_p
? "&" : NULL
);
503 find_thread_of_process (struct thread_info
*ti
, void *p
)
507 if (ptid_get_pid (ti
->ptid
) == pid
&& !is_exited (ti
->ptid
))
514 mi_cmd_target_detach (char *command
, char **argv
, int argc
)
516 if (argc
!= 0 && argc
!= 1)
517 error (_("Usage: -target-detach [pid | thread-group]"));
521 struct thread_info
*tp
;
525 /* First see if we are dealing with a thread-group id. */
528 struct inferior
*inf
;
529 int id
= strtoul (argv
[0] + 1, &end
, 0);
532 error (_("Invalid syntax of thread-group id '%s'"), argv
[0]);
534 inf
= find_inferior_id (id
);
536 error (_("Non-existent thread-group id '%d'"), id
);
542 /* We must be dealing with a pid. */
543 pid
= strtol (argv
[0], &end
, 10);
546 error (_("Invalid identifier '%s'"), argv
[0]);
549 /* Pick any thread in the desired process. Current
550 target_detach detaches from the parent of inferior_ptid. */
551 tp
= iterate_over_threads (find_thread_of_process
, &pid
);
553 error (_("Thread group is empty"));
555 switch_to_thread (tp
->ptid
);
558 detach_command (NULL
, 0);
562 mi_cmd_thread_select (char *command
, char **argv
, int argc
)
565 char *mi_error_message
;
568 error (_("-thread-select: USAGE: threadnum."));
570 rc
= gdb_thread_select (current_uiout
, argv
[0], &mi_error_message
);
572 if (rc
== GDB_RC_FAIL
)
574 make_cleanup (xfree
, mi_error_message
);
575 error ("%s", mi_error_message
);
580 mi_cmd_thread_list_ids (char *command
, char **argv
, int argc
)
583 char *mi_error_message
;
586 error (_("-thread-list-ids: No arguments required."));
588 rc
= gdb_list_thread_ids (current_uiout
, &mi_error_message
);
590 if (rc
== GDB_RC_FAIL
)
592 make_cleanup (xfree
, mi_error_message
);
593 error ("%s", mi_error_message
);
598 mi_cmd_thread_info (char *command
, char **argv
, int argc
)
600 if (argc
!= 0 && argc
!= 1)
601 error (_("Invalid MI command"));
603 print_thread_info (current_uiout
, argv
[0], -1);
606 struct collect_cores_data
614 collect_cores (struct thread_info
*ti
, void *xdata
)
616 struct collect_cores_data
*data
= (struct collect_cores_data
*) xdata
;
618 if (ptid_get_pid (ti
->ptid
) == data
->pid
)
620 int core
= target_core_of_thread (ti
->ptid
);
623 VEC_safe_push (int, data
->cores
, core
);
630 unique (int *b
, int *e
)
640 struct print_one_inferior_data
643 VEC (int) *inferiors
;
647 print_one_inferior (struct inferior
*inferior
, void *xdata
)
649 struct print_one_inferior_data
*top_data
650 = (struct print_one_inferior_data
*) xdata
;
651 struct ui_out
*uiout
= current_uiout
;
653 if (VEC_empty (int, top_data
->inferiors
)
654 || bsearch (&(inferior
->pid
), VEC_address (int, top_data
->inferiors
),
655 VEC_length (int, top_data
->inferiors
), sizeof (int),
656 compare_positive_ints
))
658 struct collect_cores_data data
;
659 struct cleanup
*back_to
660 = make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
662 ui_out_field_fmt (uiout
, "id", "i%d", inferior
->num
);
663 ui_out_field_string (uiout
, "type", "process");
664 if (inferior
->has_exit_code
)
665 ui_out_field_string (uiout
, "exit-code",
666 int_string (inferior
->exit_code
, 8, 0, 0, 1));
667 if (inferior
->pid
!= 0)
668 ui_out_field_int (uiout
, "pid", inferior
->pid
);
670 if (inferior
->pspace
->pspace_exec_filename
!= NULL
)
672 ui_out_field_string (uiout
, "executable",
673 inferior
->pspace
->pspace_exec_filename
);
677 if (inferior
->pid
!= 0)
679 data
.pid
= inferior
->pid
;
680 iterate_over_threads (collect_cores
, &data
);
683 if (!VEC_empty (int, data
.cores
))
686 struct cleanup
*back_to_2
=
687 make_cleanup_ui_out_list_begin_end (uiout
, "cores");
689 qsort (VEC_address (int, data
.cores
),
690 VEC_length (int, data
.cores
), sizeof (int),
691 compare_positive_ints
);
693 b
= VEC_address (int, data
.cores
);
694 e
= b
+ VEC_length (int, data
.cores
);
698 ui_out_field_int (uiout
, NULL
, *b
);
700 do_cleanups (back_to_2
);
703 if (top_data
->recurse
)
704 print_thread_info (uiout
, NULL
, inferior
->pid
);
706 do_cleanups (back_to
);
712 /* Output a field named 'cores' with a list as the value. The
713 elements of the list are obtained by splitting 'cores' on
717 output_cores (struct ui_out
*uiout
, const char *field_name
, const char *xcores
)
719 struct cleanup
*back_to
= make_cleanup_ui_out_list_begin_end (uiout
,
721 char *cores
= xstrdup (xcores
);
724 make_cleanup (xfree
, cores
);
726 for (p
= strtok (p
, ","); p
; p
= strtok (NULL
, ","))
727 ui_out_field_string (uiout
, NULL
, p
);
729 do_cleanups (back_to
);
733 free_vector_of_ints (void *xvector
)
735 VEC (int) **vector
= (VEC (int) **) xvector
;
737 VEC_free (int, *vector
);
741 do_nothing (splay_tree_key k
)
746 free_vector_of_osdata_items (splay_tree_value xvalue
)
748 VEC (osdata_item_s
) *value
= (VEC (osdata_item_s
) *) xvalue
;
750 /* We don't free the items itself, it will be done separately. */
751 VEC_free (osdata_item_s
, value
);
755 splay_tree_int_comparator (splay_tree_key xa
, splay_tree_key xb
)
764 free_splay_tree (void *xt
)
766 splay_tree t
= (splay_tree
) xt
;
767 splay_tree_delete (t
);
771 list_available_thread_groups (VEC (int) *ids
, int recurse
)
774 struct osdata_item
*item
;
776 struct ui_out
*uiout
= current_uiout
;
777 struct cleanup
*cleanup
;
779 /* This keeps a map from integer (pid) to VEC (struct osdata_item *)*
780 The vector contains information about all threads for the given pid.
781 This is assigned an initial value to avoid "may be used uninitialized"
783 splay_tree tree
= NULL
;
785 /* get_osdata will throw if it cannot return data. */
786 data
= get_osdata ("processes");
787 cleanup
= make_cleanup_osdata_free (data
);
791 struct osdata
*threads
= get_osdata ("threads");
793 make_cleanup_osdata_free (threads
);
794 tree
= splay_tree_new (splay_tree_int_comparator
,
796 free_vector_of_osdata_items
);
797 make_cleanup (free_splay_tree
, tree
);
800 VEC_iterate (osdata_item_s
, threads
->items
,
804 const char *pid
= get_osdata_column (item
, "pid");
805 int pid_i
= strtoul (pid
, NULL
, 0);
806 VEC (osdata_item_s
) *vec
= 0;
808 splay_tree_node n
= splay_tree_lookup (tree
, pid_i
);
811 VEC_safe_push (osdata_item_s
, vec
, item
);
812 splay_tree_insert (tree
, pid_i
, (splay_tree_value
)vec
);
816 vec
= (VEC (osdata_item_s
) *) n
->value
;
817 VEC_safe_push (osdata_item_s
, vec
, item
);
818 n
->value
= (splay_tree_value
) vec
;
823 make_cleanup_ui_out_list_begin_end (uiout
, "groups");
826 VEC_iterate (osdata_item_s
, data
->items
,
830 struct cleanup
*back_to
;
832 const char *pid
= get_osdata_column (item
, "pid");
833 const char *cmd
= get_osdata_column (item
, "command");
834 const char *user
= get_osdata_column (item
, "user");
835 const char *cores
= get_osdata_column (item
, "cores");
837 int pid_i
= strtoul (pid
, NULL
, 0);
839 /* At present, the target will return all available processes
840 and if information about specific ones was required, we filter
841 undesired processes here. */
842 if (ids
&& bsearch (&pid_i
, VEC_address (int, ids
),
843 VEC_length (int, ids
),
844 sizeof (int), compare_positive_ints
) == NULL
)
848 back_to
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
850 ui_out_field_fmt (uiout
, "id", "%s", pid
);
851 ui_out_field_string (uiout
, "type", "process");
853 ui_out_field_string (uiout
, "description", cmd
);
855 ui_out_field_string (uiout
, "user", user
);
857 output_cores (uiout
, "cores", cores
);
861 splay_tree_node n
= splay_tree_lookup (tree
, pid_i
);
864 VEC (osdata_item_s
) *children
= (VEC (osdata_item_s
) *) n
->value
;
865 struct osdata_item
*child
;
868 make_cleanup_ui_out_list_begin_end (uiout
, "threads");
871 VEC_iterate (osdata_item_s
, children
, ix_child
, child
);
874 struct cleanup
*back_to_2
=
875 make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
876 const char *tid
= get_osdata_column (child
, "tid");
877 const char *tcore
= get_osdata_column (child
, "core");
879 ui_out_field_string (uiout
, "id", tid
);
881 ui_out_field_string (uiout
, "core", tcore
);
883 do_cleanups (back_to_2
);
888 do_cleanups (back_to
);
891 do_cleanups (cleanup
);
895 mi_cmd_list_thread_groups (char *command
, char **argv
, int argc
)
897 struct ui_out
*uiout
= current_uiout
;
898 struct cleanup
*back_to
;
905 AVAILABLE_OPT
, RECURSE_OPT
907 static const struct mi_opt opts
[] =
909 {"-available", AVAILABLE_OPT
, 0},
910 {"-recurse", RECURSE_OPT
, 1},
919 int opt
= mi_getopt ("-list-thread-groups", argc
, argv
, opts
,
924 switch ((enum opt
) opt
)
930 if (strcmp (oarg
, "0") == 0)
932 else if (strcmp (oarg
, "1") == 0)
935 error (_("only '0' and '1' are valid values "
936 "for the '--recurse' option"));
941 for (; oind
< argc
; ++oind
)
946 if (*(argv
[oind
]) != 'i')
947 error (_("invalid syntax of group id '%s'"), argv
[oind
]);
949 inf
= strtoul (argv
[oind
] + 1, &end
, 0);
952 error (_("invalid syntax of group id '%s'"), argv
[oind
]);
953 VEC_safe_push (int, ids
, inf
);
955 if (VEC_length (int, ids
) > 1)
956 qsort (VEC_address (int, ids
),
957 VEC_length (int, ids
),
958 sizeof (int), compare_positive_ints
);
960 back_to
= make_cleanup (free_vector_of_ints
, &ids
);
964 list_available_thread_groups (ids
, recurse
);
966 else if (VEC_length (int, ids
) == 1)
968 /* Local thread groups, single id. */
969 int id
= *VEC_address (int, ids
);
970 struct inferior
*inf
= find_inferior_id (id
);
973 error (_("Non-existent thread group id '%d'"), id
);
975 print_thread_info (uiout
, NULL
, inf
->pid
);
979 struct print_one_inferior_data data
;
981 data
.recurse
= recurse
;
982 data
.inferiors
= ids
;
984 /* Local thread groups. Either no explicit ids -- and we
985 print everything, or several explicit ids. In both cases,
986 we print more than one group, and have to use 'groups'
987 as the top-level element. */
988 make_cleanup_ui_out_list_begin_end (uiout
, "groups");
989 update_thread_list ();
990 iterate_over_inferiors (print_one_inferior
, &data
);
993 do_cleanups (back_to
);
997 mi_cmd_data_list_register_names (char *command
, char **argv
, int argc
)
999 struct gdbarch
*gdbarch
;
1000 struct ui_out
*uiout
= current_uiout
;
1001 int regnum
, numregs
;
1003 struct cleanup
*cleanup
;
1005 /* Note that the test for a valid register must include checking the
1006 gdbarch_register_name because gdbarch_num_regs may be allocated
1007 for the union of the register sets within a family of related
1008 processors. In this case, some entries of gdbarch_register_name
1009 will change depending upon the particular processor being
1012 gdbarch
= get_current_arch ();
1013 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1015 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "register-names");
1017 if (argc
== 0) /* No args, just do all the regs. */
1023 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1024 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1025 ui_out_field_string (uiout
, NULL
, "");
1027 ui_out_field_string (uiout
, NULL
,
1028 gdbarch_register_name (gdbarch
, regnum
));
1032 /* Else, list of register #s, just do listed regs. */
1033 for (i
= 0; i
< argc
; i
++)
1035 regnum
= atoi (argv
[i
]);
1036 if (regnum
< 0 || regnum
>= numregs
)
1037 error (_("bad register number"));
1039 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1040 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1041 ui_out_field_string (uiout
, NULL
, "");
1043 ui_out_field_string (uiout
, NULL
,
1044 gdbarch_register_name (gdbarch
, regnum
));
1046 do_cleanups (cleanup
);
1050 mi_cmd_data_list_changed_registers (char *command
, char **argv
, int argc
)
1052 static struct regcache
*this_regs
= NULL
;
1053 struct ui_out
*uiout
= current_uiout
;
1054 struct regcache
*prev_regs
;
1055 struct gdbarch
*gdbarch
;
1056 int regnum
, numregs
, changed
;
1058 struct cleanup
*cleanup
;
1060 /* The last time we visited this function, the current frame's
1061 register contents were saved in THIS_REGS. Move THIS_REGS over
1062 to PREV_REGS, and refresh THIS_REGS with the now-current register
1065 prev_regs
= this_regs
;
1066 this_regs
= frame_save_as_regcache (get_selected_frame (NULL
));
1067 cleanup
= make_cleanup_regcache_xfree (prev_regs
);
1069 /* Note that the test for a valid register must include checking the
1070 gdbarch_register_name because gdbarch_num_regs may be allocated
1071 for the union of the register sets within a family of related
1072 processors. In this case, some entries of gdbarch_register_name
1073 will change depending upon the particular processor being
1076 gdbarch
= get_regcache_arch (this_regs
);
1077 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1079 make_cleanup_ui_out_list_begin_end (uiout
, "changed-registers");
1083 /* No args, just do all the regs. */
1088 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1089 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1091 changed
= register_changed_p (regnum
, prev_regs
, this_regs
);
1093 error (_("-data-list-changed-registers: "
1094 "Unable to read register contents."));
1096 ui_out_field_int (uiout
, NULL
, regnum
);
1100 /* Else, list of register #s, just do listed regs. */
1101 for (i
= 0; i
< argc
; i
++)
1103 regnum
= atoi (argv
[i
]);
1107 && gdbarch_register_name (gdbarch
, regnum
) != NULL
1108 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
1110 changed
= register_changed_p (regnum
, prev_regs
, this_regs
);
1112 error (_("-data-list-changed-registers: "
1113 "Unable to read register contents."));
1115 ui_out_field_int (uiout
, NULL
, regnum
);
1118 error (_("bad register number"));
1120 do_cleanups (cleanup
);
1124 register_changed_p (int regnum
, struct regcache
*prev_regs
,
1125 struct regcache
*this_regs
)
1127 struct gdbarch
*gdbarch
= get_regcache_arch (this_regs
);
1128 gdb_byte prev_buffer
[MAX_REGISTER_SIZE
];
1129 gdb_byte this_buffer
[MAX_REGISTER_SIZE
];
1130 enum register_status prev_status
;
1131 enum register_status this_status
;
1133 /* First time through or after gdbarch change consider all registers
1135 if (!prev_regs
|| get_regcache_arch (prev_regs
) != gdbarch
)
1138 /* Get register contents and compare. */
1139 prev_status
= regcache_cooked_read (prev_regs
, regnum
, prev_buffer
);
1140 this_status
= regcache_cooked_read (this_regs
, regnum
, this_buffer
);
1142 if (this_status
!= prev_status
)
1144 else if (this_status
== REG_VALID
)
1145 return memcmp (prev_buffer
, this_buffer
,
1146 register_size (gdbarch
, regnum
)) != 0;
1151 /* Return a list of register number and value pairs. The valid
1152 arguments expected are: a letter indicating the format in which to
1153 display the registers contents. This can be one of: x
1154 (hexadecimal), d (decimal), N (natural), t (binary), o (octal), r
1155 (raw). After the format argument there can be a sequence of
1156 numbers, indicating which registers to fetch the content of. If
1157 the format is the only argument, a list of all the registers with
1158 their values is returned. */
1161 mi_cmd_data_list_register_values (char *command
, char **argv
, int argc
)
1163 struct ui_out
*uiout
= current_uiout
;
1164 struct frame_info
*frame
;
1165 struct gdbarch
*gdbarch
;
1166 int regnum
, numregs
, format
;
1168 struct cleanup
*list_cleanup
;
1169 int skip_unavailable
= 0;
1175 static const struct mi_opt opts
[] =
1177 {"-skip-unavailable", SKIP_UNAVAILABLE
, 0},
1181 /* Note that the test for a valid register must include checking the
1182 gdbarch_register_name because gdbarch_num_regs may be allocated
1183 for the union of the register sets within a family of related
1184 processors. In this case, some entries of gdbarch_register_name
1185 will change depending upon the particular processor being
1191 int opt
= mi_getopt ("-data-list-register-values", argc
, argv
,
1192 opts
, &oind
, &oarg
);
1196 switch ((enum opt
) opt
)
1198 case SKIP_UNAVAILABLE
:
1199 skip_unavailable
= 1;
1204 if (argc
- oind
< 1)
1205 error (_("-data-list-register-values: Usage: "
1206 "-data-list-register-values [--skip-unavailable] <format>"
1207 " [<regnum1>...<regnumN>]"));
1209 format
= (int) argv
[oind
][0];
1211 frame
= get_selected_frame (NULL
);
1212 gdbarch
= get_frame_arch (frame
);
1213 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1215 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "register-values");
1217 if (argc
- oind
== 1)
1219 /* No args, beside the format: do all the regs. */
1224 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1225 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1228 output_register (frame
, regnum
, format
, skip_unavailable
);
1232 /* Else, list of register #s, just do listed regs. */
1233 for (i
= 1 + oind
; i
< argc
; i
++)
1235 regnum
= atoi (argv
[i
]);
1239 && gdbarch_register_name (gdbarch
, regnum
) != NULL
1240 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
1241 output_register (frame
, regnum
, format
, skip_unavailable
);
1243 error (_("bad register number"));
1245 do_cleanups (list_cleanup
);
1248 /* Output one register REGNUM's contents in the desired FORMAT. If
1249 SKIP_UNAVAILABLE is true, skip the register if it is
1253 output_register (struct frame_info
*frame
, int regnum
, int format
,
1254 int skip_unavailable
)
1256 struct ui_out
*uiout
= current_uiout
;
1257 struct value
*val
= value_of_register (regnum
, frame
);
1258 struct cleanup
*tuple_cleanup
;
1259 struct value_print_options opts
;
1260 struct ui_file
*stb
;
1262 if (skip_unavailable
&& !value_entirely_available (val
))
1265 tuple_cleanup
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1266 ui_out_field_int (uiout
, "number", regnum
);
1274 stb
= mem_fileopen ();
1275 make_cleanup_ui_file_delete (stb
);
1277 get_formatted_print_options (&opts
, format
);
1279 val_print (value_type (val
),
1280 value_contents_for_printing (val
),
1281 value_embedded_offset (val
), 0,
1282 stb
, 0, val
, &opts
, current_language
);
1283 ui_out_field_stream (uiout
, "value", stb
);
1285 do_cleanups (tuple_cleanup
);
1288 /* Write given values into registers. The registers and values are
1289 given as pairs. The corresponding MI command is
1290 -data-write-register-values <format>
1291 [<regnum1> <value1>...<regnumN> <valueN>] */
1293 mi_cmd_data_write_register_values (char *command
, char **argv
, int argc
)
1295 struct regcache
*regcache
;
1296 struct gdbarch
*gdbarch
;
1299 /* Note that the test for a valid register must include checking the
1300 gdbarch_register_name because gdbarch_num_regs may be allocated
1301 for the union of the register sets within a family of related
1302 processors. In this case, some entries of gdbarch_register_name
1303 will change depending upon the particular processor being
1306 regcache
= get_current_regcache ();
1307 gdbarch
= get_regcache_arch (regcache
);
1308 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1311 error (_("-data-write-register-values: Usage: -data-write-register-"
1312 "values <format> [<regnum1> <value1>...<regnumN> <valueN>]"));
1314 if (!target_has_registers
)
1315 error (_("-data-write-register-values: No registers."));
1318 error (_("-data-write-register-values: No regs and values specified."));
1321 error (_("-data-write-register-values: "
1322 "Regs and vals are not in pairs."));
1324 for (i
= 1; i
< argc
; i
= i
+ 2)
1326 int regnum
= atoi (argv
[i
]);
1328 if (regnum
>= 0 && regnum
< numregs
1329 && gdbarch_register_name (gdbarch
, regnum
)
1330 && *gdbarch_register_name (gdbarch
, regnum
))
1334 /* Get the value as a number. */
1335 value
= parse_and_eval_address (argv
[i
+ 1]);
1337 /* Write it down. */
1338 regcache_cooked_write_signed (regcache
, regnum
, value
);
1341 error (_("bad register number"));
1345 /* Evaluate the value of the argument. The argument is an
1346 expression. If the expression contains spaces it needs to be
1347 included in double quotes. */
1350 mi_cmd_data_evaluate_expression (char *command
, char **argv
, int argc
)
1352 struct expression
*expr
;
1353 struct cleanup
*old_chain
;
1355 struct ui_file
*stb
;
1356 struct value_print_options opts
;
1357 struct ui_out
*uiout
= current_uiout
;
1359 stb
= mem_fileopen ();
1360 old_chain
= make_cleanup_ui_file_delete (stb
);
1363 error (_("-data-evaluate-expression: "
1364 "Usage: -data-evaluate-expression expression"));
1366 expr
= parse_expression (argv
[0]);
1368 make_cleanup (free_current_contents
, &expr
);
1370 val
= evaluate_expression (expr
);
1372 /* Print the result of the expression evaluation. */
1373 get_user_print_options (&opts
);
1375 common_val_print (val
, stb
, 0, &opts
, current_language
);
1377 ui_out_field_stream (uiout
, "value", stb
);
1379 do_cleanups (old_chain
);
1382 /* This is the -data-read-memory command.
1384 ADDR: start address of data to be dumped.
1385 WORD-FORMAT: a char indicating format for the ``word''. See
1387 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
1388 NR_ROW: Number of rows.
1389 NR_COL: The number of colums (words per row).
1390 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
1391 ASCHAR for unprintable characters.
1393 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
1394 displayes them. Returns:
1396 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
1399 The number of bytes read is SIZE*ROW*COL. */
1402 mi_cmd_data_read_memory (char *command
, char **argv
, int argc
)
1404 struct gdbarch
*gdbarch
= get_current_arch ();
1405 struct ui_out
*uiout
= current_uiout
;
1406 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
1408 long total_bytes
, nr_cols
, nr_rows
;
1410 struct type
*word_type
;
1423 static const struct mi_opt opts
[] =
1425 {"o", OFFSET_OPT
, 1},
1431 int opt
= mi_getopt ("-data-read-memory", argc
, argv
, opts
,
1436 switch ((enum opt
) opt
)
1439 offset
= atol (oarg
);
1446 if (argc
< 5 || argc
> 6)
1447 error (_("-data-read-memory: Usage: "
1448 "ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR]."));
1450 /* Extract all the arguments. */
1452 /* Start address of the memory dump. */
1453 addr
= parse_and_eval_address (argv
[0]) + offset
;
1454 /* The format character to use when displaying a memory word. See
1455 the ``x'' command. */
1456 word_format
= argv
[1][0];
1457 /* The size of the memory word. */
1458 word_size
= atol (argv
[2]);
1462 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1466 word_type
= builtin_type (gdbarch
)->builtin_int16
;
1470 word_type
= builtin_type (gdbarch
)->builtin_int32
;
1474 word_type
= builtin_type (gdbarch
)->builtin_int64
;
1478 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1481 /* The number of rows. */
1482 nr_rows
= atol (argv
[3]);
1484 error (_("-data-read-memory: invalid number of rows."));
1486 /* Number of bytes per row. */
1487 nr_cols
= atol (argv
[4]);
1489 error (_("-data-read-memory: invalid number of columns."));
1491 /* The un-printable character when printing ascii. */
1497 /* Create a buffer and read it in. */
1498 total_bytes
= word_size
* nr_rows
* nr_cols
;
1499 mbuf
= XCNEWVEC (gdb_byte
, total_bytes
);
1500 make_cleanup (xfree
, mbuf
);
1502 /* Dispatch memory reads to the topmost target, not the flattened
1504 nr_bytes
= target_read (current_target
.beneath
,
1505 TARGET_OBJECT_MEMORY
, NULL
, mbuf
,
1508 error (_("Unable to read memory."));
1510 /* Output the header information. */
1511 ui_out_field_core_addr (uiout
, "addr", gdbarch
, addr
);
1512 ui_out_field_int (uiout
, "nr-bytes", nr_bytes
);
1513 ui_out_field_int (uiout
, "total-bytes", total_bytes
);
1514 ui_out_field_core_addr (uiout
, "next-row",
1515 gdbarch
, addr
+ word_size
* nr_cols
);
1516 ui_out_field_core_addr (uiout
, "prev-row",
1517 gdbarch
, addr
- word_size
* nr_cols
);
1518 ui_out_field_core_addr (uiout
, "next-page", gdbarch
, addr
+ total_bytes
);
1519 ui_out_field_core_addr (uiout
, "prev-page", gdbarch
, addr
- total_bytes
);
1521 /* Build the result as a two dimentional table. */
1523 struct ui_file
*stream
;
1524 struct cleanup
*cleanup_stream
;
1528 stream
= mem_fileopen ();
1529 cleanup_stream
= make_cleanup_ui_file_delete (stream
);
1531 make_cleanup_ui_out_list_begin_end (uiout
, "memory");
1532 for (row
= 0, row_byte
= 0;
1534 row
++, row_byte
+= nr_cols
* word_size
)
1538 struct cleanup
*cleanup_tuple
;
1539 struct cleanup
*cleanup_list_data
;
1540 struct value_print_options opts
;
1542 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1543 ui_out_field_core_addr (uiout
, "addr", gdbarch
, addr
+ row_byte
);
1544 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr +
1546 cleanup_list_data
= make_cleanup_ui_out_list_begin_end (uiout
, "data");
1547 get_formatted_print_options (&opts
, word_format
);
1548 for (col
= 0, col_byte
= row_byte
;
1550 col
++, col_byte
+= word_size
)
1552 if (col_byte
+ word_size
> nr_bytes
)
1554 ui_out_field_string (uiout
, NULL
, "N/A");
1558 ui_file_rewind (stream
);
1559 print_scalar_formatted (mbuf
+ col_byte
, word_type
, &opts
,
1560 word_asize
, stream
);
1561 ui_out_field_stream (uiout
, NULL
, stream
);
1564 do_cleanups (cleanup_list_data
);
1569 ui_file_rewind (stream
);
1570 for (byte
= row_byte
;
1571 byte
< row_byte
+ word_size
* nr_cols
; byte
++)
1573 if (byte
>= nr_bytes
)
1574 fputc_unfiltered ('X', stream
);
1575 else if (mbuf
[byte
] < 32 || mbuf
[byte
] > 126)
1576 fputc_unfiltered (aschar
, stream
);
1578 fputc_unfiltered (mbuf
[byte
], stream
);
1580 ui_out_field_stream (uiout
, "ascii", stream
);
1582 do_cleanups (cleanup_tuple
);
1584 do_cleanups (cleanup_stream
);
1586 do_cleanups (cleanups
);
1590 mi_cmd_data_read_memory_bytes (char *command
, char **argv
, int argc
)
1592 struct gdbarch
*gdbarch
= get_current_arch ();
1593 struct ui_out
*uiout
= current_uiout
;
1594 struct cleanup
*cleanups
;
1597 memory_read_result_s
*read_result
;
1599 VEC(memory_read_result_s
) *result
;
1601 int unit_size
= gdbarch_addressable_memory_unit_size (gdbarch
);
1608 static const struct mi_opt opts
[] =
1610 {"o", OFFSET_OPT
, 1},
1616 int opt
= mi_getopt ("-data-read-memory-bytes", argc
, argv
, opts
,
1620 switch ((enum opt
) opt
)
1623 offset
= atol (oarg
);
1631 error (_("Usage: [ -o OFFSET ] ADDR LENGTH."));
1633 addr
= parse_and_eval_address (argv
[0]) + offset
;
1634 length
= atol (argv
[1]);
1636 result
= read_memory_robust (current_target
.beneath
, addr
, length
);
1638 cleanups
= make_cleanup (free_memory_read_result_vector
, result
);
1640 if (VEC_length (memory_read_result_s
, result
) == 0)
1641 error (_("Unable to read memory."));
1643 make_cleanup_ui_out_list_begin_end (uiout
, "memory");
1645 VEC_iterate (memory_read_result_s
, result
, ix
, read_result
);
1648 struct cleanup
*t
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1653 ui_out_field_core_addr (uiout
, "begin", gdbarch
, read_result
->begin
);
1654 ui_out_field_core_addr (uiout
, "offset", gdbarch
, read_result
->begin
1656 ui_out_field_core_addr (uiout
, "end", gdbarch
, read_result
->end
);
1658 alloc_len
= (read_result
->end
- read_result
->begin
) * 2 * unit_size
+ 1;
1659 data
= (char *) xmalloc (alloc_len
);
1661 for (i
= 0, p
= data
;
1662 i
< ((read_result
->end
- read_result
->begin
) * unit_size
);
1665 sprintf (p
, "%02x", read_result
->data
[i
]);
1667 ui_out_field_string (uiout
, "contents", data
);
1671 do_cleanups (cleanups
);
1674 /* Implementation of the -data-write_memory command.
1676 COLUMN_OFFSET: optional argument. Must be preceded by '-o'. The
1677 offset from the beginning of the memory grid row where the cell to
1679 ADDR: start address of the row in the memory grid where the memory
1680 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
1681 the location to write to.
1682 FORMAT: a char indicating format for the ``word''. See
1684 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
1685 VALUE: value to be written into the memory address.
1687 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1692 mi_cmd_data_write_memory (char *command
, char **argv
, int argc
)
1694 struct gdbarch
*gdbarch
= get_current_arch ();
1695 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1698 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1699 enough when using a compiler other than GCC. */
1702 struct cleanup
*old_chain
;
1710 static const struct mi_opt opts
[] =
1712 {"o", OFFSET_OPT
, 1},
1718 int opt
= mi_getopt ("-data-write-memory", argc
, argv
, opts
,
1723 switch ((enum opt
) opt
)
1726 offset
= atol (oarg
);
1734 error (_("-data-write-memory: Usage: "
1735 "[-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE."));
1737 /* Extract all the arguments. */
1738 /* Start address of the memory dump. */
1739 addr
= parse_and_eval_address (argv
[0]);
1740 /* The size of the memory word. */
1741 word_size
= atol (argv
[2]);
1743 /* Calculate the real address of the write destination. */
1744 addr
+= (offset
* word_size
);
1746 /* Get the value as a number. */
1747 value
= parse_and_eval_address (argv
[3]);
1748 /* Get the value into an array. */
1749 buffer
= (gdb_byte
*) xmalloc (word_size
);
1750 old_chain
= make_cleanup (xfree
, buffer
);
1751 store_signed_integer (buffer
, word_size
, byte_order
, value
);
1752 /* Write it down to memory. */
1753 write_memory_with_notification (addr
, buffer
, word_size
);
1754 /* Free the buffer. */
1755 do_cleanups (old_chain
);
1758 /* Implementation of the -data-write-memory-bytes command.
1761 DATA: string of bytes to write at that address
1762 COUNT: number of bytes to be filled (decimal integer). */
1765 mi_cmd_data_write_memory_bytes (char *command
, char **argv
, int argc
)
1771 size_t len_hex
, len_bytes
, len_units
, i
, steps
, remaining_units
;
1772 long int count_units
;
1773 struct cleanup
*back_to
;
1776 if (argc
!= 2 && argc
!= 3)
1777 error (_("Usage: ADDR DATA [COUNT]."));
1779 addr
= parse_and_eval_address (argv
[0]);
1781 len_hex
= strlen (cdata
);
1782 unit_size
= gdbarch_addressable_memory_unit_size (get_current_arch ());
1784 if (len_hex
% (unit_size
* 2) != 0)
1785 error (_("Hex-encoded '%s' must represent an integral number of "
1786 "addressable memory units."),
1789 len_bytes
= len_hex
/ 2;
1790 len_units
= len_bytes
/ unit_size
;
1793 count_units
= strtoul (argv
[2], NULL
, 10);
1795 count_units
= len_units
;
1797 databuf
= XNEWVEC (gdb_byte
, len_bytes
);
1798 back_to
= make_cleanup (xfree
, databuf
);
1800 for (i
= 0; i
< len_bytes
; ++i
)
1803 if (sscanf (cdata
+ i
* 2, "%02x", &x
) != 1)
1804 error (_("Invalid argument"));
1805 databuf
[i
] = (gdb_byte
) x
;
1808 if (len_units
< count_units
)
1810 /* Pattern is made of less units than count:
1811 repeat pattern to fill memory. */
1812 data
= (gdb_byte
*) xmalloc (count_units
* unit_size
);
1813 make_cleanup (xfree
, data
);
1815 /* Number of times the pattern is entirely repeated. */
1816 steps
= count_units
/ len_units
;
1817 /* Number of remaining addressable memory units. */
1818 remaining_units
= count_units
% len_units
;
1819 for (i
= 0; i
< steps
; i
++)
1820 memcpy (data
+ i
* len_bytes
, databuf
, len_bytes
);
1822 if (remaining_units
> 0)
1823 memcpy (data
+ steps
* len_bytes
, databuf
,
1824 remaining_units
* unit_size
);
1828 /* Pattern is longer than or equal to count:
1829 just copy count addressable memory units. */
1833 write_memory_with_notification (addr
, data
, count_units
);
1835 do_cleanups (back_to
);
1839 mi_cmd_enable_timings (char *command
, char **argv
, int argc
)
1845 if (strcmp (argv
[0], "yes") == 0)
1847 else if (strcmp (argv
[0], "no") == 0)
1858 error (_("-enable-timings: Usage: %s {yes|no}"), command
);
1862 mi_cmd_list_features (char *command
, char **argv
, int argc
)
1866 struct cleanup
*cleanup
= NULL
;
1867 struct ui_out
*uiout
= current_uiout
;
1869 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "features");
1870 ui_out_field_string (uiout
, NULL
, "frozen-varobjs");
1871 ui_out_field_string (uiout
, NULL
, "pending-breakpoints");
1872 ui_out_field_string (uiout
, NULL
, "thread-info");
1873 ui_out_field_string (uiout
, NULL
, "data-read-memory-bytes");
1874 ui_out_field_string (uiout
, NULL
, "breakpoint-notifications");
1875 ui_out_field_string (uiout
, NULL
, "ada-task-info");
1876 ui_out_field_string (uiout
, NULL
, "language-option");
1877 ui_out_field_string (uiout
, NULL
, "info-gdb-mi-command");
1878 ui_out_field_string (uiout
, NULL
, "undefined-command-error-code");
1879 ui_out_field_string (uiout
, NULL
, "exec-run-start-option");
1881 if (ext_lang_initialized_p (get_ext_lang_defn (EXT_LANG_PYTHON
)))
1882 ui_out_field_string (uiout
, NULL
, "python");
1884 do_cleanups (cleanup
);
1888 error (_("-list-features should be passed no arguments"));
1892 mi_cmd_list_target_features (char *command
, char **argv
, int argc
)
1896 struct cleanup
*cleanup
= NULL
;
1897 struct ui_out
*uiout
= current_uiout
;
1899 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "features");
1901 ui_out_field_string (uiout
, NULL
, "async");
1902 if (target_can_execute_reverse
)
1903 ui_out_field_string (uiout
, NULL
, "reverse");
1904 do_cleanups (cleanup
);
1908 error (_("-list-target-features should be passed no arguments"));
1912 mi_cmd_add_inferior (char *command
, char **argv
, int argc
)
1914 struct inferior
*inf
;
1917 error (_("-add-inferior should be passed no arguments"));
1919 inf
= add_inferior_with_spaces ();
1921 ui_out_field_fmt (current_uiout
, "inferior", "i%d", inf
->num
);
1924 /* Callback used to find the first inferior other than the current
1928 get_other_inferior (struct inferior
*inf
, void *arg
)
1930 if (inf
== current_inferior ())
1937 mi_cmd_remove_inferior (char *command
, char **argv
, int argc
)
1940 struct inferior
*inf
;
1943 error (_("-remove-inferior should be passed a single argument"));
1945 if (sscanf (argv
[0], "i%d", &id
) != 1)
1946 error (_("the thread group id is syntactically invalid"));
1948 inf
= find_inferior_id (id
);
1950 error (_("the specified thread group does not exist"));
1953 error (_("cannot remove an active inferior"));
1955 if (inf
== current_inferior ())
1957 struct thread_info
*tp
= 0;
1958 struct inferior
*new_inferior
1959 = iterate_over_inferiors (get_other_inferior
, NULL
);
1961 if (new_inferior
== NULL
)
1962 error (_("Cannot remove last inferior"));
1964 set_current_inferior (new_inferior
);
1965 if (new_inferior
->pid
!= 0)
1966 tp
= any_thread_of_process (new_inferior
->pid
);
1967 switch_to_thread (tp
? tp
->ptid
: null_ptid
);
1968 set_current_program_space (new_inferior
->pspace
);
1971 delete_inferior (inf
);
1976 /* Execute a command within a safe environment.
1977 Return <0 for error; >=0 for ok.
1979 args->action will tell mi_execute_command what action
1980 to perfrom after the given command has executed (display/suppress
1981 prompt, display error). */
1984 captured_mi_execute_command (struct ui_out
*uiout
, struct mi_parse
*context
)
1986 struct cleanup
*cleanup
;
1989 current_command_ts
= context
->cmd_start
;
1991 current_token
= xstrdup (context
->token
);
1992 cleanup
= make_cleanup (free_current_contents
, ¤t_token
);
1994 running_result_record_printed
= 0;
1996 switch (context
->op
)
1999 /* A MI command was read from the input stream. */
2001 /* FIXME: gdb_???? */
2002 fprintf_unfiltered (raw_stdout
, " token=`%s' command=`%s' args=`%s'\n",
2003 context
->token
, context
->command
, context
->args
);
2005 mi_cmd_execute (context
);
2007 /* Print the result if there were no errors.
2009 Remember that on the way out of executing a command, you have
2010 to directly use the mi_interp's uiout, since the command
2011 could have reset the interpreter, in which case the current
2012 uiout will most likely crash in the mi_out_* routines. */
2013 if (!running_result_record_printed
)
2015 fputs_unfiltered (context
->token
, raw_stdout
);
2016 /* There's no particularly good reason why target-connect results
2017 in not ^done. Should kill ^connected for MI3. */
2018 fputs_unfiltered (strcmp (context
->command
, "target-select") == 0
2019 ? "^connected" : "^done", raw_stdout
);
2020 mi_out_put (uiout
, raw_stdout
);
2021 mi_out_rewind (uiout
);
2022 mi_print_timing_maybe ();
2023 fputs_unfiltered ("\n", raw_stdout
);
2026 /* The command does not want anything to be printed. In that
2027 case, the command probably should not have written anything
2028 to uiout, but in case it has written something, discard it. */
2029 mi_out_rewind (uiout
);
2036 /* A CLI command was read from the input stream. */
2037 /* This "feature" will be removed as soon as we have a
2038 complete set of mi commands. */
2039 /* Echo the command on the console. */
2040 fprintf_unfiltered (gdb_stdlog
, "%s\n", context
->command
);
2041 /* Call the "console" interpreter. */
2042 argv
[0] = "console";
2043 argv
[1] = context
->command
;
2044 mi_cmd_interpreter_exec ("-interpreter-exec", argv
, 2);
2046 /* If we changed interpreters, DON'T print out anything. */
2047 if (current_interp_named_p (INTERP_MI
)
2048 || current_interp_named_p (INTERP_MI1
)
2049 || current_interp_named_p (INTERP_MI2
)
2050 || current_interp_named_p (INTERP_MI3
))
2052 if (!running_result_record_printed
)
2054 fputs_unfiltered (context
->token
, raw_stdout
);
2055 fputs_unfiltered ("^done", raw_stdout
);
2056 mi_out_put (uiout
, raw_stdout
);
2057 mi_out_rewind (uiout
);
2058 mi_print_timing_maybe ();
2059 fputs_unfiltered ("\n", raw_stdout
);
2062 mi_out_rewind (uiout
);
2068 do_cleanups (cleanup
);
2071 /* Print a gdb exception to the MI output stream. */
2074 mi_print_exception (const char *token
, struct gdb_exception exception
)
2076 fputs_unfiltered (token
, raw_stdout
);
2077 fputs_unfiltered ("^error,msg=\"", raw_stdout
);
2078 if (exception
.message
== NULL
)
2079 fputs_unfiltered ("unknown error", raw_stdout
);
2081 fputstr_unfiltered (exception
.message
, '"', raw_stdout
);
2082 fputs_unfiltered ("\"", raw_stdout
);
2084 switch (exception
.error
)
2086 case UNDEFINED_COMMAND_ERROR
:
2087 fputs_unfiltered (",code=\"undefined-command\"", raw_stdout
);
2091 fputs_unfiltered ("\n", raw_stdout
);
2095 mi_execute_command (const char *cmd
, int from_tty
)
2098 struct mi_parse
*command
= NULL
;
2100 /* This is to handle EOF (^D). We just quit gdb. */
2101 /* FIXME: we should call some API function here. */
2103 quit_force (NULL
, from_tty
);
2105 target_log_command (cmd
);
2109 command
= mi_parse (cmd
, &token
);
2111 CATCH (exception
, RETURN_MASK_ALL
)
2113 mi_print_exception (token
, exception
);
2118 if (command
!= NULL
)
2120 ptid_t previous_ptid
= inferior_ptid
;
2122 command
->token
= token
;
2126 command
->cmd_start
= XNEW (struct mi_timestamp
);
2127 timestamp (command
->cmd_start
);
2132 captured_mi_execute_command (current_uiout
, command
);
2134 CATCH (result
, RETURN_MASK_ALL
)
2136 /* The command execution failed and error() was called
2138 mi_print_exception (command
->token
, result
);
2139 mi_out_rewind (current_uiout
);
2143 bpstat_do_actions ();
2145 if (/* The notifications are only output when the top-level
2146 interpreter (specified on the command line) is MI. */
2147 ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ()))
2148 /* Don't try report anything if there are no threads --
2149 the program is dead. */
2150 && thread_count () != 0
2151 /* -thread-select explicitly changes thread. If frontend uses that
2152 internally, we don't want to emit =thread-selected, since
2153 =thread-selected is supposed to indicate user's intentions. */
2154 && strcmp (command
->command
, "thread-select") != 0)
2156 struct mi_interp
*mi
2157 = (struct mi_interp
*) top_level_interpreter_data ();
2158 int report_change
= 0;
2160 if (command
->thread
== -1)
2162 report_change
= (!ptid_equal (previous_ptid
, null_ptid
)
2163 && !ptid_equal (inferior_ptid
, previous_ptid
)
2164 && !ptid_equal (inferior_ptid
, null_ptid
));
2166 else if (!ptid_equal (inferior_ptid
, null_ptid
))
2168 struct thread_info
*ti
= inferior_thread ();
2170 report_change
= (ti
->global_num
!= command
->thread
);
2175 struct thread_info
*ti
= inferior_thread ();
2176 struct cleanup
*old_chain
;
2178 old_chain
= make_cleanup_restore_target_terminal ();
2179 target_terminal_ours_for_output ();
2181 fprintf_unfiltered (mi
->event_channel
,
2182 "thread-selected,id=\"%d\"",
2184 gdb_flush (mi
->event_channel
);
2186 do_cleanups (old_chain
);
2190 mi_parse_free (command
);
2195 mi_cmd_execute (struct mi_parse
*parse
)
2197 struct cleanup
*cleanup
;
2199 cleanup
= prepare_execute_command ();
2201 if (parse
->all
&& parse
->thread_group
!= -1)
2202 error (_("Cannot specify --thread-group together with --all"));
2204 if (parse
->all
&& parse
->thread
!= -1)
2205 error (_("Cannot specify --thread together with --all"));
2207 if (parse
->thread_group
!= -1 && parse
->thread
!= -1)
2208 error (_("Cannot specify --thread together with --thread-group"));
2210 if (parse
->frame
!= -1 && parse
->thread
== -1)
2211 error (_("Cannot specify --frame without --thread"));
2213 if (parse
->thread_group
!= -1)
2215 struct inferior
*inf
= find_inferior_id (parse
->thread_group
);
2216 struct thread_info
*tp
= 0;
2219 error (_("Invalid thread group for the --thread-group option"));
2221 set_current_inferior (inf
);
2222 /* This behaviour means that if --thread-group option identifies
2223 an inferior with multiple threads, then a random one will be
2224 picked. This is not a problem -- frontend should always
2225 provide --thread if it wishes to operate on a specific
2228 tp
= any_live_thread_of_process (inf
->pid
);
2229 switch_to_thread (tp
? tp
->ptid
: null_ptid
);
2230 set_current_program_space (inf
->pspace
);
2233 if (parse
->thread
!= -1)
2235 struct thread_info
*tp
= find_thread_global_id (parse
->thread
);
2238 error (_("Invalid thread id: %d"), parse
->thread
);
2240 if (is_exited (tp
->ptid
))
2241 error (_("Thread id: %d has terminated"), parse
->thread
);
2243 switch_to_thread (tp
->ptid
);
2246 if (parse
->frame
!= -1)
2248 struct frame_info
*fid
;
2249 int frame
= parse
->frame
;
2251 fid
= find_relative_frame (get_current_frame (), &frame
);
2253 /* find_relative_frame was successful */
2256 error (_("Invalid frame id: %d"), frame
);
2259 if (parse
->language
!= language_unknown
)
2261 make_cleanup_restore_current_language ();
2262 set_language (parse
->language
);
2265 current_context
= parse
;
2267 if (parse
->cmd
->suppress_notification
!= NULL
)
2269 make_cleanup_restore_integer (parse
->cmd
->suppress_notification
);
2270 *parse
->cmd
->suppress_notification
= 1;
2273 if (parse
->cmd
->argv_func
!= NULL
)
2275 parse
->cmd
->argv_func (parse
->command
, parse
->argv
, parse
->argc
);
2277 else if (parse
->cmd
->cli
.cmd
!= 0)
2279 /* FIXME: DELETE THIS. */
2280 /* The operation is still implemented by a cli command. */
2281 /* Must be a synchronous one. */
2282 mi_execute_cli_command (parse
->cmd
->cli
.cmd
, parse
->cmd
->cli
.args_p
,
2287 /* FIXME: DELETE THIS. */
2288 struct ui_file
*stb
;
2290 stb
= mem_fileopen ();
2292 fputs_unfiltered ("Undefined mi command: ", stb
);
2293 fputstr_unfiltered (parse
->command
, '"', stb
);
2294 fputs_unfiltered (" (missing implementation)", stb
);
2296 make_cleanup_ui_file_delete (stb
);
2299 do_cleanups (cleanup
);
2302 /* FIXME: This is just a hack so we can get some extra commands going.
2303 We don't want to channel things through the CLI, but call libgdb directly.
2304 Use only for synchronous commands. */
2307 mi_execute_cli_command (const char *cmd
, int args_p
, const char *args
)
2311 struct cleanup
*old_cleanups
;
2315 run
= xstrprintf ("%s %s", cmd
, args
);
2317 run
= xstrdup (cmd
);
2319 /* FIXME: gdb_???? */
2320 fprintf_unfiltered (gdb_stdout
, "cli=%s run=%s\n",
2322 old_cleanups
= make_cleanup (xfree
, run
);
2323 execute_command (run
, 0 /* from_tty */ );
2324 do_cleanups (old_cleanups
);
2330 mi_execute_async_cli_command (char *cli_command
, char **argv
, int argc
)
2332 struct cleanup
*old_cleanups
;
2336 run
= xstrprintf ("%s %s&", cli_command
, argc
? *argv
: "");
2338 run
= xstrprintf ("%s %s", cli_command
, argc
? *argv
: "");
2339 old_cleanups
= make_cleanup (xfree
, run
);
2341 execute_command (run
, 0 /* from_tty */ );
2343 /* Do this before doing any printing. It would appear that some
2344 print code leaves garbage around in the buffer. */
2345 do_cleanups (old_cleanups
);
2349 mi_load_progress (const char *section_name
,
2350 unsigned long sent_so_far
,
2351 unsigned long total_section
,
2352 unsigned long total_sent
,
2353 unsigned long grand_total
)
2355 struct timeval time_now
, delta
, update_threshold
;
2356 static struct timeval last_update
;
2357 static char *previous_sect_name
= NULL
;
2359 struct ui_out
*saved_uiout
;
2360 struct ui_out
*uiout
;
2362 /* This function is called through deprecated_show_load_progress
2363 which means uiout may not be correct. Fix it for the duration
2364 of this function. */
2365 saved_uiout
= current_uiout
;
2367 if (current_interp_named_p (INTERP_MI
)
2368 || current_interp_named_p (INTERP_MI2
))
2369 current_uiout
= mi_out_new (2);
2370 else if (current_interp_named_p (INTERP_MI1
))
2371 current_uiout
= mi_out_new (1);
2372 else if (current_interp_named_p (INTERP_MI3
))
2373 current_uiout
= mi_out_new (3);
2377 uiout
= current_uiout
;
2379 update_threshold
.tv_sec
= 0;
2380 update_threshold
.tv_usec
= 500000;
2381 gettimeofday (&time_now
, NULL
);
2383 delta
.tv_usec
= time_now
.tv_usec
- last_update
.tv_usec
;
2384 delta
.tv_sec
= time_now
.tv_sec
- last_update
.tv_sec
;
2386 if (delta
.tv_usec
< 0)
2389 delta
.tv_usec
+= 1000000L;
2392 new_section
= (previous_sect_name
?
2393 strcmp (previous_sect_name
, section_name
) : 1);
2396 struct cleanup
*cleanup_tuple
;
2398 xfree (previous_sect_name
);
2399 previous_sect_name
= xstrdup (section_name
);
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-size", total_section
);
2407 ui_out_field_int (uiout
, "total-size", grand_total
);
2408 do_cleanups (cleanup_tuple
);
2409 mi_out_put (uiout
, raw_stdout
);
2410 fputs_unfiltered ("\n", raw_stdout
);
2411 gdb_flush (raw_stdout
);
2414 if (delta
.tv_sec
>= update_threshold
.tv_sec
&&
2415 delta
.tv_usec
>= update_threshold
.tv_usec
)
2417 struct cleanup
*cleanup_tuple
;
2419 last_update
.tv_sec
= time_now
.tv_sec
;
2420 last_update
.tv_usec
= time_now
.tv_usec
;
2422 fputs_unfiltered (current_token
, raw_stdout
);
2423 fputs_unfiltered ("+download", raw_stdout
);
2424 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2425 ui_out_field_string (uiout
, "section", section_name
);
2426 ui_out_field_int (uiout
, "section-sent", sent_so_far
);
2427 ui_out_field_int (uiout
, "section-size", total_section
);
2428 ui_out_field_int (uiout
, "total-sent", total_sent
);
2429 ui_out_field_int (uiout
, "total-size", grand_total
);
2430 do_cleanups (cleanup_tuple
);
2431 mi_out_put (uiout
, raw_stdout
);
2432 fputs_unfiltered ("\n", raw_stdout
);
2433 gdb_flush (raw_stdout
);
2437 current_uiout
= saved_uiout
;
2441 timestamp (struct mi_timestamp
*tv
)
2443 gettimeofday (&tv
->wallclock
, NULL
);
2444 #ifdef HAVE_GETRUSAGE
2445 getrusage (RUSAGE_SELF
, &rusage
);
2446 tv
->utime
.tv_sec
= rusage
.ru_utime
.tv_sec
;
2447 tv
->utime
.tv_usec
= rusage
.ru_utime
.tv_usec
;
2448 tv
->stime
.tv_sec
= rusage
.ru_stime
.tv_sec
;
2449 tv
->stime
.tv_usec
= rusage
.ru_stime
.tv_usec
;
2452 long usec
= get_run_time ();
2454 tv
->utime
.tv_sec
= usec
/1000000L;
2455 tv
->utime
.tv_usec
= usec
- 1000000L*tv
->utime
.tv_sec
;
2456 tv
->stime
.tv_sec
= 0;
2457 tv
->stime
.tv_usec
= 0;
2463 print_diff_now (struct mi_timestamp
*start
)
2465 struct mi_timestamp now
;
2468 print_diff (start
, &now
);
2472 mi_print_timing_maybe (void)
2474 /* If the command is -enable-timing then do_timings may be true
2475 whilst current_command_ts is not initialized. */
2476 if (do_timings
&& current_command_ts
)
2477 print_diff_now (current_command_ts
);
2481 timeval_diff (struct timeval start
, struct timeval end
)
2483 return ((end
.tv_sec
- start
.tv_sec
) * 1000000L)
2484 + (end
.tv_usec
- start
.tv_usec
);
2488 print_diff (struct mi_timestamp
*start
, struct mi_timestamp
*end
)
2492 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
2493 timeval_diff (start
->wallclock
, end
->wallclock
) / 1000000.0,
2494 timeval_diff (start
->utime
, end
->utime
) / 1000000.0,
2495 timeval_diff (start
->stime
, end
->stime
) / 1000000.0);
2499 mi_cmd_trace_define_variable (char *command
, char **argv
, int argc
)
2501 LONGEST initval
= 0;
2502 struct trace_state_variable
*tsv
;
2505 if (argc
!= 1 && argc
!= 2)
2506 error (_("Usage: -trace-define-variable VARIABLE [VALUE]"));
2510 error (_("Name of trace variable should start with '$'"));
2512 validate_trace_state_variable_name (name
);
2514 tsv
= find_trace_state_variable (name
);
2516 tsv
= create_trace_state_variable (name
);
2519 initval
= value_as_long (parse_and_eval (argv
[1]));
2521 tsv
->initial_value
= initval
;
2525 mi_cmd_trace_list_variables (char *command
, char **argv
, int argc
)
2528 error (_("-trace-list-variables: no arguments allowed"));
2530 tvariables_info_1 ();
2534 mi_cmd_trace_find (char *command
, char **argv
, int argc
)
2539 error (_("trace selection mode is required"));
2543 if (strcmp (mode
, "none") == 0)
2545 tfind_1 (tfind_number
, -1, 0, 0, 0);
2549 check_trace_running (current_trace_status ());
2551 if (strcmp (mode
, "frame-number") == 0)
2554 error (_("frame number is required"));
2555 tfind_1 (tfind_number
, atoi (argv
[1]), 0, 0, 0);
2557 else if (strcmp (mode
, "tracepoint-number") == 0)
2560 error (_("tracepoint number is required"));
2561 tfind_1 (tfind_tp
, atoi (argv
[1]), 0, 0, 0);
2563 else if (strcmp (mode
, "pc") == 0)
2566 error (_("PC is required"));
2567 tfind_1 (tfind_pc
, 0, parse_and_eval_address (argv
[1]), 0, 0);
2569 else if (strcmp (mode
, "pc-inside-range") == 0)
2572 error (_("Start and end PC are required"));
2573 tfind_1 (tfind_range
, 0, parse_and_eval_address (argv
[1]),
2574 parse_and_eval_address (argv
[2]), 0);
2576 else if (strcmp (mode
, "pc-outside-range") == 0)
2579 error (_("Start and end PC are required"));
2580 tfind_1 (tfind_outside
, 0, parse_and_eval_address (argv
[1]),
2581 parse_and_eval_address (argv
[2]), 0);
2583 else if (strcmp (mode
, "line") == 0)
2585 struct symtabs_and_lines sals
;
2586 struct symtab_and_line sal
;
2587 static CORE_ADDR start_pc
, end_pc
;
2588 struct cleanup
*back_to
;
2591 error (_("Line is required"));
2593 sals
= decode_line_with_current_source (argv
[1],
2594 DECODE_LINE_FUNFIRSTLINE
);
2595 back_to
= make_cleanup (xfree
, sals
.sals
);
2599 if (sal
.symtab
== 0)
2600 error (_("Could not find the specified line"));
2602 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2603 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, 0);
2605 error (_("Could not find the specified line"));
2607 do_cleanups (back_to
);
2610 error (_("Invalid mode '%s'"), mode
);
2612 if (has_stack_frames () || get_traceframe_number () >= 0)
2613 print_stack_frame (get_selected_frame (NULL
), 1, LOC_AND_ADDRESS
, 1);
2617 mi_cmd_trace_save (char *command
, char **argv
, int argc
)
2619 int target_saves
= 0;
2620 int generate_ctf
= 0;
2627 TARGET_SAVE_OPT
, CTF_OPT
2629 static const struct mi_opt opts
[] =
2631 {"r", TARGET_SAVE_OPT
, 0},
2632 {"ctf", CTF_OPT
, 0},
2638 int opt
= mi_getopt ("-trace-save", argc
, argv
, opts
,
2643 switch ((enum opt
) opt
)
2645 case TARGET_SAVE_OPT
:
2653 filename
= argv
[oind
];
2656 trace_save_ctf (filename
, target_saves
);
2658 trace_save_tfile (filename
, target_saves
);
2662 mi_cmd_trace_start (char *command
, char **argv
, int argc
)
2664 start_tracing (NULL
);
2668 mi_cmd_trace_status (char *command
, char **argv
, int argc
)
2670 trace_status_mi (0);
2674 mi_cmd_trace_stop (char *command
, char **argv
, int argc
)
2676 stop_tracing (NULL
);
2677 trace_status_mi (1);
2680 /* Implement the "-ada-task-info" command. */
2683 mi_cmd_ada_task_info (char *command
, char **argv
, int argc
)
2685 if (argc
!= 0 && argc
!= 1)
2686 error (_("Invalid MI command"));
2688 print_ada_task_info (current_uiout
, argv
[0], current_inferior ());
2691 /* Print EXPRESSION according to VALUES. */
2694 print_variable_or_computed (char *expression
, enum print_values values
)
2696 struct expression
*expr
;
2697 struct cleanup
*old_chain
;
2699 struct ui_file
*stb
;
2701 struct ui_out
*uiout
= current_uiout
;
2703 stb
= mem_fileopen ();
2704 old_chain
= make_cleanup_ui_file_delete (stb
);
2706 expr
= parse_expression (expression
);
2708 make_cleanup (free_current_contents
, &expr
);
2710 if (values
== PRINT_SIMPLE_VALUES
)
2711 val
= evaluate_type (expr
);
2713 val
= evaluate_expression (expr
);
2715 if (values
!= PRINT_NO_VALUES
)
2716 make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2717 ui_out_field_string (uiout
, "name", expression
);
2721 case PRINT_SIMPLE_VALUES
:
2722 type
= check_typedef (value_type (val
));
2723 type_print (value_type (val
), "", stb
, -1);
2724 ui_out_field_stream (uiout
, "type", stb
);
2725 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
2726 && TYPE_CODE (type
) != TYPE_CODE_STRUCT
2727 && TYPE_CODE (type
) != TYPE_CODE_UNION
)
2729 struct value_print_options opts
;
2731 get_no_prettyformat_print_options (&opts
);
2733 common_val_print (val
, stb
, 0, &opts
, current_language
);
2734 ui_out_field_stream (uiout
, "value", stb
);
2737 case PRINT_ALL_VALUES
:
2739 struct value_print_options opts
;
2741 get_no_prettyformat_print_options (&opts
);
2743 common_val_print (val
, stb
, 0, &opts
, current_language
);
2744 ui_out_field_stream (uiout
, "value", stb
);
2749 do_cleanups (old_chain
);
2752 /* Implement the "-trace-frame-collected" command. */
2755 mi_cmd_trace_frame_collected (char *command
, char **argv
, int argc
)
2757 struct cleanup
*old_chain
;
2758 struct bp_location
*tloc
;
2760 struct collection_list
*clist
;
2761 struct collection_list tracepoint_list
, stepping_list
;
2762 struct traceframe_info
*tinfo
;
2764 enum print_values var_print_values
= PRINT_ALL_VALUES
;
2765 enum print_values comp_print_values
= PRINT_ALL_VALUES
;
2766 int registers_format
= 'x';
2767 int memory_contents
= 0;
2768 struct ui_out
*uiout
= current_uiout
;
2776 static const struct mi_opt opts
[] =
2778 {"-var-print-values", VAR_PRINT_VALUES
, 1},
2779 {"-comp-print-values", COMP_PRINT_VALUES
, 1},
2780 {"-registers-format", REGISTERS_FORMAT
, 1},
2781 {"-memory-contents", MEMORY_CONTENTS
, 0},
2788 int opt
= mi_getopt ("-trace-frame-collected", argc
, argv
, opts
,
2792 switch ((enum opt
) opt
)
2794 case VAR_PRINT_VALUES
:
2795 var_print_values
= mi_parse_print_values (oarg
);
2797 case COMP_PRINT_VALUES
:
2798 comp_print_values
= mi_parse_print_values (oarg
);
2800 case REGISTERS_FORMAT
:
2801 registers_format
= oarg
[0];
2802 case MEMORY_CONTENTS
:
2803 memory_contents
= 1;
2809 error (_("Usage: -trace-frame-collected "
2810 "[--var-print-values PRINT_VALUES] "
2811 "[--comp-print-values PRINT_VALUES] "
2812 "[--registers-format FORMAT]"
2813 "[--memory-contents]"));
2815 /* This throws an error is not inspecting a trace frame. */
2816 tloc
= get_traceframe_location (&stepping_frame
);
2818 /* This command only makes sense for the current frame, not the
2820 old_chain
= make_cleanup_restore_current_thread ();
2821 select_frame (get_current_frame ());
2823 encode_actions_and_make_cleanup (tloc
, &tracepoint_list
,
2827 clist
= &stepping_list
;
2829 clist
= &tracepoint_list
;
2831 tinfo
= get_traceframe_info ();
2833 /* Explicitly wholly collected variables. */
2835 struct cleanup
*list_cleanup
;
2839 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
,
2840 "explicit-variables");
2841 for (i
= 0; VEC_iterate (char_ptr
, clist
->wholly_collected
, i
, p
); i
++)
2842 print_variable_or_computed (p
, var_print_values
);
2843 do_cleanups (list_cleanup
);
2846 /* Computed expressions. */
2848 struct cleanup
*list_cleanup
;
2853 = make_cleanup_ui_out_list_begin_end (uiout
,
2854 "computed-expressions");
2855 for (i
= 0; VEC_iterate (char_ptr
, clist
->computed
, i
, p
); i
++)
2856 print_variable_or_computed (p
, comp_print_values
);
2857 do_cleanups (list_cleanup
);
2860 /* Registers. Given pseudo-registers, and that some architectures
2861 (like MIPS) actually hide the raw registers, we don't go through
2862 the trace frame info, but instead consult the register cache for
2863 register availability. */
2865 struct cleanup
*list_cleanup
;
2866 struct frame_info
*frame
;
2867 struct gdbarch
*gdbarch
;
2871 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "registers");
2873 frame
= get_selected_frame (NULL
);
2874 gdbarch
= get_frame_arch (frame
);
2875 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
2877 for (regnum
= 0; regnum
< numregs
; regnum
++)
2879 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
2880 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
2883 output_register (frame
, regnum
, registers_format
, 1);
2886 do_cleanups (list_cleanup
);
2889 /* Trace state variables. */
2891 struct cleanup
*list_cleanup
;
2896 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "tvars");
2899 make_cleanup (free_current_contents
, &tsvname
);
2901 for (i
= 0; VEC_iterate (int, tinfo
->tvars
, i
, tvar
); i
++)
2903 struct cleanup
*cleanup_child
;
2904 struct trace_state_variable
*tsv
;
2906 tsv
= find_trace_state_variable_by_number (tvar
);
2908 cleanup_child
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2912 tsvname
= (char *) xrealloc (tsvname
, strlen (tsv
->name
) + 2);
2914 strcpy (tsvname
+ 1, tsv
->name
);
2915 ui_out_field_string (uiout
, "name", tsvname
);
2917 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
2919 ui_out_field_int (uiout
, "current", tsv
->value
);
2923 ui_out_field_skip (uiout
, "name");
2924 ui_out_field_skip (uiout
, "current");
2927 do_cleanups (cleanup_child
);
2930 do_cleanups (list_cleanup
);
2935 struct cleanup
*list_cleanup
;
2936 VEC(mem_range_s
) *available_memory
= NULL
;
2937 struct mem_range
*r
;
2940 traceframe_available_memory (&available_memory
, 0, ULONGEST_MAX
);
2941 make_cleanup (VEC_cleanup(mem_range_s
), &available_memory
);
2943 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "memory");
2945 for (i
= 0; VEC_iterate (mem_range_s
, available_memory
, i
, r
); i
++)
2947 struct cleanup
*cleanup_child
;
2949 struct gdbarch
*gdbarch
= target_gdbarch ();
2951 cleanup_child
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2953 ui_out_field_core_addr (uiout
, "address", gdbarch
, r
->start
);
2954 ui_out_field_int (uiout
, "length", r
->length
);
2956 data
= (gdb_byte
*) xmalloc (r
->length
);
2957 make_cleanup (xfree
, data
);
2959 if (memory_contents
)
2961 if (target_read_memory (r
->start
, data
, r
->length
) == 0)
2966 data_str
= (char *) xmalloc (r
->length
* 2 + 1);
2967 make_cleanup (xfree
, data_str
);
2969 for (m
= 0, p
= data_str
; m
< r
->length
; ++m
, p
+= 2)
2970 sprintf (p
, "%02x", data
[m
]);
2971 ui_out_field_string (uiout
, "contents", data_str
);
2974 ui_out_field_skip (uiout
, "contents");
2976 do_cleanups (cleanup_child
);
2979 do_cleanups (list_cleanup
);
2982 do_cleanups (old_chain
);
2986 _initialize_mi_main (void)
2988 struct cmd_list_element
*c
;
2990 add_setshow_boolean_cmd ("mi-async", class_run
,
2992 Set whether MI asynchronous mode is enabled."), _("\
2993 Show whether MI asynchronous mode is enabled."), _("\
2994 Tells GDB whether MI should be in asynchronous mode."),
2995 set_mi_async_command
,
2996 show_mi_async_command
,
3000 /* Alias old "target-async" to "mi-async". */
3001 c
= add_alias_cmd ("target-async", "mi-async", class_run
, 0, &setlist
);
3002 deprecate_cmd (c
, "set mi-async");
3003 c
= add_alias_cmd ("target-async", "mi-async", class_run
, 0, &showlist
);
3004 deprecate_cmd (c
, "show mi-async");