3 Copyright (C) 2000-2015 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";
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
= (struct collect_cores_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
647 = (struct print_one_inferior_data
*) xdata
;
648 struct ui_out
*uiout
= current_uiout
;
650 if (VEC_empty (int, top_data
->inferiors
)
651 || bsearch (&(inferior
->pid
), VEC_address (int, top_data
->inferiors
),
652 VEC_length (int, top_data
->inferiors
), sizeof (int),
653 compare_positive_ints
))
655 struct collect_cores_data data
;
656 struct cleanup
*back_to
657 = make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
659 ui_out_field_fmt (uiout
, "id", "i%d", inferior
->num
);
660 ui_out_field_string (uiout
, "type", "process");
661 if (inferior
->has_exit_code
)
662 ui_out_field_string (uiout
, "exit-code",
663 int_string (inferior
->exit_code
, 8, 0, 0, 1));
664 if (inferior
->pid
!= 0)
665 ui_out_field_int (uiout
, "pid", inferior
->pid
);
667 if (inferior
->pspace
->pspace_exec_filename
!= NULL
)
669 ui_out_field_string (uiout
, "executable",
670 inferior
->pspace
->pspace_exec_filename
);
674 if (inferior
->pid
!= 0)
676 data
.pid
= inferior
->pid
;
677 iterate_over_threads (collect_cores
, &data
);
680 if (!VEC_empty (int, data
.cores
))
683 struct cleanup
*back_to_2
=
684 make_cleanup_ui_out_list_begin_end (uiout
, "cores");
686 qsort (VEC_address (int, data
.cores
),
687 VEC_length (int, data
.cores
), sizeof (int),
688 compare_positive_ints
);
690 b
= VEC_address (int, data
.cores
);
691 e
= b
+ VEC_length (int, data
.cores
);
695 ui_out_field_int (uiout
, NULL
, *b
);
697 do_cleanups (back_to_2
);
700 if (top_data
->recurse
)
701 print_thread_info (uiout
, NULL
, inferior
->pid
);
703 do_cleanups (back_to
);
709 /* Output a field named 'cores' with a list as the value. The
710 elements of the list are obtained by splitting 'cores' on
714 output_cores (struct ui_out
*uiout
, const char *field_name
, const char *xcores
)
716 struct cleanup
*back_to
= make_cleanup_ui_out_list_begin_end (uiout
,
718 char *cores
= xstrdup (xcores
);
721 make_cleanup (xfree
, cores
);
723 for (p
= strtok (p
, ","); p
; p
= strtok (NULL
, ","))
724 ui_out_field_string (uiout
, NULL
, p
);
726 do_cleanups (back_to
);
730 free_vector_of_ints (void *xvector
)
732 VEC (int) **vector
= (VEC (int) **) xvector
;
734 VEC_free (int, *vector
);
738 do_nothing (splay_tree_key k
)
743 free_vector_of_osdata_items (splay_tree_value xvalue
)
745 VEC (osdata_item_s
) *value
= (VEC (osdata_item_s
) *) xvalue
;
747 /* We don't free the items itself, it will be done separately. */
748 VEC_free (osdata_item_s
, value
);
752 splay_tree_int_comparator (splay_tree_key xa
, splay_tree_key xb
)
761 free_splay_tree (void *xt
)
763 splay_tree t
= (splay_tree
) xt
;
764 splay_tree_delete (t
);
768 list_available_thread_groups (VEC (int) *ids
, int recurse
)
771 struct osdata_item
*item
;
773 struct ui_out
*uiout
= current_uiout
;
774 struct cleanup
*cleanup
;
776 /* This keeps a map from integer (pid) to VEC (struct osdata_item *)*
777 The vector contains information about all threads for the given pid.
778 This is assigned an initial value to avoid "may be used uninitialized"
780 splay_tree tree
= NULL
;
782 /* get_osdata will throw if it cannot return data. */
783 data
= get_osdata ("processes");
784 cleanup
= make_cleanup_osdata_free (data
);
788 struct osdata
*threads
= get_osdata ("threads");
790 make_cleanup_osdata_free (threads
);
791 tree
= splay_tree_new (splay_tree_int_comparator
,
793 free_vector_of_osdata_items
);
794 make_cleanup (free_splay_tree
, tree
);
797 VEC_iterate (osdata_item_s
, threads
->items
,
801 const char *pid
= get_osdata_column (item
, "pid");
802 int pid_i
= strtoul (pid
, NULL
, 0);
803 VEC (osdata_item_s
) *vec
= 0;
805 splay_tree_node n
= splay_tree_lookup (tree
, pid_i
);
808 VEC_safe_push (osdata_item_s
, vec
, item
);
809 splay_tree_insert (tree
, pid_i
, (splay_tree_value
)vec
);
813 vec
= (VEC (osdata_item_s
) *) n
->value
;
814 VEC_safe_push (osdata_item_s
, vec
, item
);
815 n
->value
= (splay_tree_value
) vec
;
820 make_cleanup_ui_out_list_begin_end (uiout
, "groups");
823 VEC_iterate (osdata_item_s
, data
->items
,
827 struct cleanup
*back_to
;
829 const char *pid
= get_osdata_column (item
, "pid");
830 const char *cmd
= get_osdata_column (item
, "command");
831 const char *user
= get_osdata_column (item
, "user");
832 const char *cores
= get_osdata_column (item
, "cores");
834 int pid_i
= strtoul (pid
, NULL
, 0);
836 /* At present, the target will return all available processes
837 and if information about specific ones was required, we filter
838 undesired processes here. */
839 if (ids
&& bsearch (&pid_i
, VEC_address (int, ids
),
840 VEC_length (int, ids
),
841 sizeof (int), compare_positive_ints
) == NULL
)
845 back_to
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
847 ui_out_field_fmt (uiout
, "id", "%s", pid
);
848 ui_out_field_string (uiout
, "type", "process");
850 ui_out_field_string (uiout
, "description", cmd
);
852 ui_out_field_string (uiout
, "user", user
);
854 output_cores (uiout
, "cores", cores
);
858 splay_tree_node n
= splay_tree_lookup (tree
, pid_i
);
861 VEC (osdata_item_s
) *children
= (VEC (osdata_item_s
) *) n
->value
;
862 struct osdata_item
*child
;
865 make_cleanup_ui_out_list_begin_end (uiout
, "threads");
868 VEC_iterate (osdata_item_s
, children
, ix_child
, child
);
871 struct cleanup
*back_to_2
=
872 make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
873 const char *tid
= get_osdata_column (child
, "tid");
874 const char *tcore
= get_osdata_column (child
, "core");
876 ui_out_field_string (uiout
, "id", tid
);
878 ui_out_field_string (uiout
, "core", tcore
);
880 do_cleanups (back_to_2
);
885 do_cleanups (back_to
);
888 do_cleanups (cleanup
);
892 mi_cmd_list_thread_groups (char *command
, char **argv
, int argc
)
894 struct ui_out
*uiout
= current_uiout
;
895 struct cleanup
*back_to
;
902 AVAILABLE_OPT
, RECURSE_OPT
904 static const struct mi_opt opts
[] =
906 {"-available", AVAILABLE_OPT
, 0},
907 {"-recurse", RECURSE_OPT
, 1},
916 int opt
= mi_getopt ("-list-thread-groups", argc
, argv
, opts
,
921 switch ((enum opt
) opt
)
927 if (strcmp (oarg
, "0") == 0)
929 else if (strcmp (oarg
, "1") == 0)
932 error (_("only '0' and '1' are valid values "
933 "for the '--recurse' option"));
938 for (; oind
< argc
; ++oind
)
943 if (*(argv
[oind
]) != 'i')
944 error (_("invalid syntax of group id '%s'"), argv
[oind
]);
946 inf
= strtoul (argv
[oind
] + 1, &end
, 0);
949 error (_("invalid syntax of group id '%s'"), argv
[oind
]);
950 VEC_safe_push (int, ids
, inf
);
952 if (VEC_length (int, ids
) > 1)
953 qsort (VEC_address (int, ids
),
954 VEC_length (int, ids
),
955 sizeof (int), compare_positive_ints
);
957 back_to
= make_cleanup (free_vector_of_ints
, &ids
);
961 list_available_thread_groups (ids
, recurse
);
963 else if (VEC_length (int, ids
) == 1)
965 /* Local thread groups, single id. */
966 int id
= *VEC_address (int, ids
);
967 struct inferior
*inf
= find_inferior_id (id
);
970 error (_("Non-existent thread group id '%d'"), id
);
972 print_thread_info (uiout
, NULL
, inf
->pid
);
976 struct print_one_inferior_data data
;
978 data
.recurse
= recurse
;
979 data
.inferiors
= ids
;
981 /* Local thread groups. Either no explicit ids -- and we
982 print everything, or several explicit ids. In both cases,
983 we print more than one group, and have to use 'groups'
984 as the top-level element. */
985 make_cleanup_ui_out_list_begin_end (uiout
, "groups");
986 update_thread_list ();
987 iterate_over_inferiors (print_one_inferior
, &data
);
990 do_cleanups (back_to
);
994 mi_cmd_data_list_register_names (char *command
, char **argv
, int argc
)
996 struct gdbarch
*gdbarch
;
997 struct ui_out
*uiout
= current_uiout
;
1000 struct cleanup
*cleanup
;
1002 /* Note that the test for a valid register must include checking the
1003 gdbarch_register_name because gdbarch_num_regs may be allocated
1004 for the union of the register sets within a family of related
1005 processors. In this case, some entries of gdbarch_register_name
1006 will change depending upon the particular processor being
1009 gdbarch
= get_current_arch ();
1010 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1012 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "register-names");
1014 if (argc
== 0) /* No args, just do all the regs. */
1020 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1021 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1022 ui_out_field_string (uiout
, NULL
, "");
1024 ui_out_field_string (uiout
, NULL
,
1025 gdbarch_register_name (gdbarch
, regnum
));
1029 /* Else, list of register #s, just do listed regs. */
1030 for (i
= 0; i
< argc
; i
++)
1032 regnum
= atoi (argv
[i
]);
1033 if (regnum
< 0 || regnum
>= numregs
)
1034 error (_("bad register number"));
1036 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1037 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1038 ui_out_field_string (uiout
, NULL
, "");
1040 ui_out_field_string (uiout
, NULL
,
1041 gdbarch_register_name (gdbarch
, regnum
));
1043 do_cleanups (cleanup
);
1047 mi_cmd_data_list_changed_registers (char *command
, char **argv
, int argc
)
1049 static struct regcache
*this_regs
= NULL
;
1050 struct ui_out
*uiout
= current_uiout
;
1051 struct regcache
*prev_regs
;
1052 struct gdbarch
*gdbarch
;
1053 int regnum
, numregs
, changed
;
1055 struct cleanup
*cleanup
;
1057 /* The last time we visited this function, the current frame's
1058 register contents were saved in THIS_REGS. Move THIS_REGS over
1059 to PREV_REGS, and refresh THIS_REGS with the now-current register
1062 prev_regs
= this_regs
;
1063 this_regs
= frame_save_as_regcache (get_selected_frame (NULL
));
1064 cleanup
= make_cleanup_regcache_xfree (prev_regs
);
1066 /* Note that the test for a valid register must include checking the
1067 gdbarch_register_name because gdbarch_num_regs may be allocated
1068 for the union of the register sets within a family of related
1069 processors. In this case, some entries of gdbarch_register_name
1070 will change depending upon the particular processor being
1073 gdbarch
= get_regcache_arch (this_regs
);
1074 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1076 make_cleanup_ui_out_list_begin_end (uiout
, "changed-registers");
1080 /* No args, just do all the regs. */
1085 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1086 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1088 changed
= register_changed_p (regnum
, prev_regs
, this_regs
);
1090 error (_("-data-list-changed-registers: "
1091 "Unable to read register contents."));
1093 ui_out_field_int (uiout
, NULL
, regnum
);
1097 /* Else, list of register #s, just do listed regs. */
1098 for (i
= 0; i
< argc
; i
++)
1100 regnum
= atoi (argv
[i
]);
1104 && gdbarch_register_name (gdbarch
, regnum
) != NULL
1105 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
1107 changed
= register_changed_p (regnum
, prev_regs
, this_regs
);
1109 error (_("-data-list-changed-registers: "
1110 "Unable to read register contents."));
1112 ui_out_field_int (uiout
, NULL
, regnum
);
1115 error (_("bad register number"));
1117 do_cleanups (cleanup
);
1121 register_changed_p (int regnum
, struct regcache
*prev_regs
,
1122 struct regcache
*this_regs
)
1124 struct gdbarch
*gdbarch
= get_regcache_arch (this_regs
);
1125 gdb_byte prev_buffer
[MAX_REGISTER_SIZE
];
1126 gdb_byte this_buffer
[MAX_REGISTER_SIZE
];
1127 enum register_status prev_status
;
1128 enum register_status this_status
;
1130 /* First time through or after gdbarch change consider all registers
1132 if (!prev_regs
|| get_regcache_arch (prev_regs
) != gdbarch
)
1135 /* Get register contents and compare. */
1136 prev_status
= regcache_cooked_read (prev_regs
, regnum
, prev_buffer
);
1137 this_status
= regcache_cooked_read (this_regs
, regnum
, this_buffer
);
1139 if (this_status
!= prev_status
)
1141 else if (this_status
== REG_VALID
)
1142 return memcmp (prev_buffer
, this_buffer
,
1143 register_size (gdbarch
, regnum
)) != 0;
1148 /* Return a list of register number and value pairs. The valid
1149 arguments expected are: a letter indicating the format in which to
1150 display the registers contents. This can be one of: x
1151 (hexadecimal), d (decimal), N (natural), t (binary), o (octal), r
1152 (raw). After the format argument there can be a sequence of
1153 numbers, indicating which registers to fetch the content of. If
1154 the format is the only argument, a list of all the registers with
1155 their values is returned. */
1158 mi_cmd_data_list_register_values (char *command
, char **argv
, int argc
)
1160 struct ui_out
*uiout
= current_uiout
;
1161 struct frame_info
*frame
;
1162 struct gdbarch
*gdbarch
;
1163 int regnum
, numregs
, format
;
1165 struct cleanup
*list_cleanup
;
1166 int skip_unavailable
= 0;
1172 static const struct mi_opt opts
[] =
1174 {"-skip-unavailable", SKIP_UNAVAILABLE
, 0},
1178 /* Note that the test for a valid register must include checking the
1179 gdbarch_register_name because gdbarch_num_regs may be allocated
1180 for the union of the register sets within a family of related
1181 processors. In this case, some entries of gdbarch_register_name
1182 will change depending upon the particular processor being
1188 int opt
= mi_getopt ("-data-list-register-values", argc
, argv
,
1189 opts
, &oind
, &oarg
);
1193 switch ((enum opt
) opt
)
1195 case SKIP_UNAVAILABLE
:
1196 skip_unavailable
= 1;
1201 if (argc
- oind
< 1)
1202 error (_("-data-list-register-values: Usage: "
1203 "-data-list-register-values [--skip-unavailable] <format>"
1204 " [<regnum1>...<regnumN>]"));
1206 format
= (int) argv
[oind
][0];
1208 frame
= get_selected_frame (NULL
);
1209 gdbarch
= get_frame_arch (frame
);
1210 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1212 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "register-values");
1214 if (argc
- oind
== 1)
1216 /* No args, beside the format: do all the regs. */
1221 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1222 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1225 output_register (frame
, regnum
, format
, skip_unavailable
);
1229 /* Else, list of register #s, just do listed regs. */
1230 for (i
= 1 + oind
; i
< argc
; i
++)
1232 regnum
= atoi (argv
[i
]);
1236 && gdbarch_register_name (gdbarch
, regnum
) != NULL
1237 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
1238 output_register (frame
, regnum
, format
, skip_unavailable
);
1240 error (_("bad register number"));
1242 do_cleanups (list_cleanup
);
1245 /* Output one register REGNUM's contents in the desired FORMAT. If
1246 SKIP_UNAVAILABLE is true, skip the register if it is
1250 output_register (struct frame_info
*frame
, int regnum
, int format
,
1251 int skip_unavailable
)
1253 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1254 struct ui_out
*uiout
= current_uiout
;
1255 struct value
*val
= value_of_register (regnum
, frame
);
1256 struct cleanup
*tuple_cleanup
;
1257 struct value_print_options opts
;
1258 struct ui_file
*stb
;
1260 if (skip_unavailable
&& !value_entirely_available (val
))
1263 tuple_cleanup
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1264 ui_out_field_int (uiout
, "number", regnum
);
1272 stb
= mem_fileopen ();
1273 make_cleanup_ui_file_delete (stb
);
1275 get_formatted_print_options (&opts
, format
);
1277 val_print (value_type (val
),
1278 value_contents_for_printing (val
),
1279 value_embedded_offset (val
), 0,
1280 stb
, 0, val
, &opts
, current_language
);
1281 ui_out_field_stream (uiout
, "value", stb
);
1283 do_cleanups (tuple_cleanup
);
1286 /* Write given values into registers. The registers and values are
1287 given as pairs. The corresponding MI command is
1288 -data-write-register-values <format>
1289 [<regnum1> <value1>...<regnumN> <valueN>] */
1291 mi_cmd_data_write_register_values (char *command
, char **argv
, int argc
)
1293 struct regcache
*regcache
;
1294 struct gdbarch
*gdbarch
;
1297 /* Note that the test for a valid register must include checking the
1298 gdbarch_register_name because gdbarch_num_regs may be allocated
1299 for the union of the register sets within a family of related
1300 processors. In this case, some entries of gdbarch_register_name
1301 will change depending upon the particular processor being
1304 regcache
= get_current_regcache ();
1305 gdbarch
= get_regcache_arch (regcache
);
1306 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1309 error (_("-data-write-register-values: Usage: -data-write-register-"
1310 "values <format> [<regnum1> <value1>...<regnumN> <valueN>]"));
1312 if (!target_has_registers
)
1313 error (_("-data-write-register-values: No registers."));
1316 error (_("-data-write-register-values: No regs and values specified."));
1319 error (_("-data-write-register-values: "
1320 "Regs and vals are not in pairs."));
1322 for (i
= 1; i
< argc
; i
= i
+ 2)
1324 int regnum
= atoi (argv
[i
]);
1326 if (regnum
>= 0 && regnum
< numregs
1327 && gdbarch_register_name (gdbarch
, regnum
)
1328 && *gdbarch_register_name (gdbarch
, regnum
))
1332 /* Get the value as a number. */
1333 value
= parse_and_eval_address (argv
[i
+ 1]);
1335 /* Write it down. */
1336 regcache_cooked_write_signed (regcache
, regnum
, value
);
1339 error (_("bad register number"));
1343 /* Evaluate the value of the argument. The argument is an
1344 expression. If the expression contains spaces it needs to be
1345 included in double quotes. */
1348 mi_cmd_data_evaluate_expression (char *command
, char **argv
, int argc
)
1350 struct expression
*expr
;
1351 struct cleanup
*old_chain
;
1353 struct ui_file
*stb
;
1354 struct value_print_options opts
;
1355 struct ui_out
*uiout
= current_uiout
;
1357 stb
= mem_fileopen ();
1358 old_chain
= make_cleanup_ui_file_delete (stb
);
1361 error (_("-data-evaluate-expression: "
1362 "Usage: -data-evaluate-expression expression"));
1364 expr
= parse_expression (argv
[0]);
1366 make_cleanup (free_current_contents
, &expr
);
1368 val
= evaluate_expression (expr
);
1370 /* Print the result of the expression evaluation. */
1371 get_user_print_options (&opts
);
1373 common_val_print (val
, stb
, 0, &opts
, current_language
);
1375 ui_out_field_stream (uiout
, "value", stb
);
1377 do_cleanups (old_chain
);
1380 /* This is the -data-read-memory command.
1382 ADDR: start address of data to be dumped.
1383 WORD-FORMAT: a char indicating format for the ``word''. See
1385 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
1386 NR_ROW: Number of rows.
1387 NR_COL: The number of colums (words per row).
1388 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
1389 ASCHAR for unprintable characters.
1391 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
1392 displayes them. Returns:
1394 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
1397 The number of bytes read is SIZE*ROW*COL. */
1400 mi_cmd_data_read_memory (char *command
, char **argv
, int argc
)
1402 struct gdbarch
*gdbarch
= get_current_arch ();
1403 struct ui_out
*uiout
= current_uiout
;
1404 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
1406 long total_bytes
, nr_cols
, nr_rows
;
1408 struct type
*word_type
;
1421 static const struct mi_opt opts
[] =
1423 {"o", OFFSET_OPT
, 1},
1429 int opt
= mi_getopt ("-data-read-memory", argc
, argv
, opts
,
1434 switch ((enum opt
) opt
)
1437 offset
= atol (oarg
);
1444 if (argc
< 5 || argc
> 6)
1445 error (_("-data-read-memory: Usage: "
1446 "ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR]."));
1448 /* Extract all the arguments. */
1450 /* Start address of the memory dump. */
1451 addr
= parse_and_eval_address (argv
[0]) + offset
;
1452 /* The format character to use when displaying a memory word. See
1453 the ``x'' command. */
1454 word_format
= argv
[1][0];
1455 /* The size of the memory word. */
1456 word_size
= atol (argv
[2]);
1460 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1464 word_type
= builtin_type (gdbarch
)->builtin_int16
;
1468 word_type
= builtin_type (gdbarch
)->builtin_int32
;
1472 word_type
= builtin_type (gdbarch
)->builtin_int64
;
1476 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1479 /* The number of rows. */
1480 nr_rows
= atol (argv
[3]);
1482 error (_("-data-read-memory: invalid number of rows."));
1484 /* Number of bytes per row. */
1485 nr_cols
= atol (argv
[4]);
1487 error (_("-data-read-memory: invalid number of columns."));
1489 /* The un-printable character when printing ascii. */
1495 /* Create a buffer and read it in. */
1496 total_bytes
= word_size
* nr_rows
* nr_cols
;
1497 mbuf
= XCNEWVEC (gdb_byte
, total_bytes
);
1498 make_cleanup (xfree
, mbuf
);
1500 /* Dispatch memory reads to the topmost target, not the flattened
1502 nr_bytes
= target_read (current_target
.beneath
,
1503 TARGET_OBJECT_MEMORY
, NULL
, mbuf
,
1506 error (_("Unable to read memory."));
1508 /* Output the header information. */
1509 ui_out_field_core_addr (uiout
, "addr", gdbarch
, addr
);
1510 ui_out_field_int (uiout
, "nr-bytes", nr_bytes
);
1511 ui_out_field_int (uiout
, "total-bytes", total_bytes
);
1512 ui_out_field_core_addr (uiout
, "next-row",
1513 gdbarch
, addr
+ word_size
* nr_cols
);
1514 ui_out_field_core_addr (uiout
, "prev-row",
1515 gdbarch
, addr
- word_size
* nr_cols
);
1516 ui_out_field_core_addr (uiout
, "next-page", gdbarch
, addr
+ total_bytes
);
1517 ui_out_field_core_addr (uiout
, "prev-page", gdbarch
, addr
- total_bytes
);
1519 /* Build the result as a two dimentional table. */
1521 struct ui_file
*stream
;
1522 struct cleanup
*cleanup_stream
;
1526 stream
= mem_fileopen ();
1527 cleanup_stream
= make_cleanup_ui_file_delete (stream
);
1529 make_cleanup_ui_out_list_begin_end (uiout
, "memory");
1530 for (row
= 0, row_byte
= 0;
1532 row
++, row_byte
+= nr_cols
* word_size
)
1536 struct cleanup
*cleanup_tuple
;
1537 struct cleanup
*cleanup_list_data
;
1538 struct value_print_options opts
;
1540 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1541 ui_out_field_core_addr (uiout
, "addr", gdbarch
, addr
+ row_byte
);
1542 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr +
1544 cleanup_list_data
= make_cleanup_ui_out_list_begin_end (uiout
, "data");
1545 get_formatted_print_options (&opts
, word_format
);
1546 for (col
= 0, col_byte
= row_byte
;
1548 col
++, col_byte
+= word_size
)
1550 if (col_byte
+ word_size
> nr_bytes
)
1552 ui_out_field_string (uiout
, NULL
, "N/A");
1556 ui_file_rewind (stream
);
1557 print_scalar_formatted (mbuf
+ col_byte
, word_type
, &opts
,
1558 word_asize
, stream
);
1559 ui_out_field_stream (uiout
, NULL
, stream
);
1562 do_cleanups (cleanup_list_data
);
1567 ui_file_rewind (stream
);
1568 for (byte
= row_byte
;
1569 byte
< row_byte
+ word_size
* nr_cols
; byte
++)
1571 if (byte
>= nr_bytes
)
1572 fputc_unfiltered ('X', stream
);
1573 else if (mbuf
[byte
] < 32 || mbuf
[byte
] > 126)
1574 fputc_unfiltered (aschar
, stream
);
1576 fputc_unfiltered (mbuf
[byte
], stream
);
1578 ui_out_field_stream (uiout
, "ascii", stream
);
1580 do_cleanups (cleanup_tuple
);
1582 do_cleanups (cleanup_stream
);
1584 do_cleanups (cleanups
);
1588 mi_cmd_data_read_memory_bytes (char *command
, char **argv
, int argc
)
1590 struct gdbarch
*gdbarch
= get_current_arch ();
1591 struct ui_out
*uiout
= current_uiout
;
1592 struct cleanup
*cleanups
;
1595 memory_read_result_s
*read_result
;
1597 VEC(memory_read_result_s
) *result
;
1599 int unit_size
= gdbarch_addressable_memory_unit_size (gdbarch
);
1606 static const struct mi_opt opts
[] =
1608 {"o", OFFSET_OPT
, 1},
1614 int opt
= mi_getopt ("-data-read-memory-bytes", argc
, argv
, opts
,
1618 switch ((enum opt
) opt
)
1621 offset
= atol (oarg
);
1629 error (_("Usage: [ -o OFFSET ] ADDR LENGTH."));
1631 addr
= parse_and_eval_address (argv
[0]) + offset
;
1632 length
= atol (argv
[1]);
1634 result
= read_memory_robust (current_target
.beneath
, addr
, length
);
1636 cleanups
= make_cleanup (free_memory_read_result_vector
, result
);
1638 if (VEC_length (memory_read_result_s
, result
) == 0)
1639 error (_("Unable to read memory."));
1641 make_cleanup_ui_out_list_begin_end (uiout
, "memory");
1643 VEC_iterate (memory_read_result_s
, result
, ix
, read_result
);
1646 struct cleanup
*t
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1651 ui_out_field_core_addr (uiout
, "begin", gdbarch
, read_result
->begin
);
1652 ui_out_field_core_addr (uiout
, "offset", gdbarch
, read_result
->begin
1654 ui_out_field_core_addr (uiout
, "end", gdbarch
, read_result
->end
);
1656 alloc_len
= (read_result
->end
- read_result
->begin
) * 2 * unit_size
+ 1;
1657 data
= (char *) xmalloc (alloc_len
);
1659 for (i
= 0, p
= data
;
1660 i
< ((read_result
->end
- read_result
->begin
) * unit_size
);
1663 sprintf (p
, "%02x", read_result
->data
[i
]);
1665 ui_out_field_string (uiout
, "contents", data
);
1669 do_cleanups (cleanups
);
1672 /* Implementation of the -data-write_memory command.
1674 COLUMN_OFFSET: optional argument. Must be preceded by '-o'. The
1675 offset from the beginning of the memory grid row where the cell to
1677 ADDR: start address of the row in the memory grid where the memory
1678 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
1679 the location to write to.
1680 FORMAT: a char indicating format for the ``word''. See
1682 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
1683 VALUE: value to be written into the memory address.
1685 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1690 mi_cmd_data_write_memory (char *command
, char **argv
, int argc
)
1692 struct gdbarch
*gdbarch
= get_current_arch ();
1693 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1696 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1697 enough when using a compiler other than GCC. */
1700 struct cleanup
*old_chain
;
1708 static const struct mi_opt opts
[] =
1710 {"o", OFFSET_OPT
, 1},
1716 int opt
= mi_getopt ("-data-write-memory", argc
, argv
, opts
,
1721 switch ((enum opt
) opt
)
1724 offset
= atol (oarg
);
1732 error (_("-data-write-memory: Usage: "
1733 "[-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE."));
1735 /* Extract all the arguments. */
1736 /* Start address of the memory dump. */
1737 addr
= parse_and_eval_address (argv
[0]);
1738 /* The size of the memory word. */
1739 word_size
= atol (argv
[2]);
1741 /* Calculate the real address of the write destination. */
1742 addr
+= (offset
* word_size
);
1744 /* Get the value as a number. */
1745 value
= parse_and_eval_address (argv
[3]);
1746 /* Get the value into an array. */
1747 buffer
= xmalloc (word_size
);
1748 old_chain
= make_cleanup (xfree
, buffer
);
1749 store_signed_integer (buffer
, word_size
, byte_order
, value
);
1750 /* Write it down to memory. */
1751 write_memory_with_notification (addr
, buffer
, word_size
);
1752 /* Free the buffer. */
1753 do_cleanups (old_chain
);
1756 /* Implementation of the -data-write-memory-bytes command.
1759 DATA: string of bytes to write at that address
1760 COUNT: number of bytes to be filled (decimal integer). */
1763 mi_cmd_data_write_memory_bytes (char *command
, char **argv
, int argc
)
1769 size_t len_hex
, len_bytes
, len_units
, i
, steps
, remaining_units
;
1770 long int count_units
;
1771 struct cleanup
*back_to
;
1774 if (argc
!= 2 && argc
!= 3)
1775 error (_("Usage: ADDR DATA [COUNT]."));
1777 addr
= parse_and_eval_address (argv
[0]);
1779 len_hex
= strlen (cdata
);
1780 unit_size
= gdbarch_addressable_memory_unit_size (get_current_arch ());
1782 if (len_hex
% (unit_size
* 2) != 0)
1783 error (_("Hex-encoded '%s' must represent an integral number of "
1784 "addressable memory units."),
1787 len_bytes
= len_hex
/ 2;
1788 len_units
= len_bytes
/ unit_size
;
1791 count_units
= strtoul (argv
[2], NULL
, 10);
1793 count_units
= len_units
;
1795 databuf
= XNEWVEC (gdb_byte
, len_bytes
);
1796 back_to
= make_cleanup (xfree
, databuf
);
1798 for (i
= 0; i
< len_bytes
; ++i
)
1801 if (sscanf (cdata
+ i
* 2, "%02x", &x
) != 1)
1802 error (_("Invalid argument"));
1803 databuf
[i
] = (gdb_byte
) x
;
1806 if (len_units
< count_units
)
1808 /* Pattern is made of less units than count:
1809 repeat pattern to fill memory. */
1810 data
= (gdb_byte
*) xmalloc (count_units
* unit_size
);
1811 make_cleanup (xfree
, data
);
1813 /* Number of times the pattern is entirely repeated. */
1814 steps
= count_units
/ len_units
;
1815 /* Number of remaining addressable memory units. */
1816 remaining_units
= count_units
% len_units
;
1817 for (i
= 0; i
< steps
; i
++)
1818 memcpy (data
+ i
* len_bytes
, databuf
, len_bytes
);
1820 if (remaining_units
> 0)
1821 memcpy (data
+ steps
* len_bytes
, databuf
,
1822 remaining_units
* unit_size
);
1826 /* Pattern is longer than or equal to count:
1827 just copy count addressable memory units. */
1831 write_memory_with_notification (addr
, data
, count_units
);
1833 do_cleanups (back_to
);
1837 mi_cmd_enable_timings (char *command
, char **argv
, int argc
)
1843 if (strcmp (argv
[0], "yes") == 0)
1845 else if (strcmp (argv
[0], "no") == 0)
1856 error (_("-enable-timings: Usage: %s {yes|no}"), command
);
1860 mi_cmd_list_features (char *command
, char **argv
, int argc
)
1864 struct cleanup
*cleanup
= NULL
;
1865 struct ui_out
*uiout
= current_uiout
;
1867 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "features");
1868 ui_out_field_string (uiout
, NULL
, "frozen-varobjs");
1869 ui_out_field_string (uiout
, NULL
, "pending-breakpoints");
1870 ui_out_field_string (uiout
, NULL
, "thread-info");
1871 ui_out_field_string (uiout
, NULL
, "data-read-memory-bytes");
1872 ui_out_field_string (uiout
, NULL
, "breakpoint-notifications");
1873 ui_out_field_string (uiout
, NULL
, "ada-task-info");
1874 ui_out_field_string (uiout
, NULL
, "language-option");
1875 ui_out_field_string (uiout
, NULL
, "info-gdb-mi-command");
1876 ui_out_field_string (uiout
, NULL
, "undefined-command-error-code");
1877 ui_out_field_string (uiout
, NULL
, "exec-run-start-option");
1879 if (ext_lang_initialized_p (get_ext_lang_defn (EXT_LANG_PYTHON
)))
1880 ui_out_field_string (uiout
, NULL
, "python");
1882 do_cleanups (cleanup
);
1886 error (_("-list-features should be passed no arguments"));
1890 mi_cmd_list_target_features (char *command
, char **argv
, int argc
)
1894 struct cleanup
*cleanup
= NULL
;
1895 struct ui_out
*uiout
= current_uiout
;
1897 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "features");
1899 ui_out_field_string (uiout
, NULL
, "async");
1900 if (target_can_execute_reverse
)
1901 ui_out_field_string (uiout
, NULL
, "reverse");
1902 do_cleanups (cleanup
);
1906 error (_("-list-target-features should be passed no arguments"));
1910 mi_cmd_add_inferior (char *command
, char **argv
, int argc
)
1912 struct inferior
*inf
;
1915 error (_("-add-inferior should be passed no arguments"));
1917 inf
= add_inferior_with_spaces ();
1919 ui_out_field_fmt (current_uiout
, "inferior", "i%d", inf
->num
);
1922 /* Callback used to find the first inferior other than the current
1926 get_other_inferior (struct inferior
*inf
, void *arg
)
1928 if (inf
== current_inferior ())
1935 mi_cmd_remove_inferior (char *command
, char **argv
, int argc
)
1938 struct inferior
*inf
;
1941 error (_("-remove-inferior should be passed a single argument"));
1943 if (sscanf (argv
[0], "i%d", &id
) != 1)
1944 error (_("the thread group id is syntactically invalid"));
1946 inf
= find_inferior_id (id
);
1948 error (_("the specified thread group does not exist"));
1951 error (_("cannot remove an active inferior"));
1953 if (inf
== current_inferior ())
1955 struct thread_info
*tp
= 0;
1956 struct inferior
*new_inferior
1957 = iterate_over_inferiors (get_other_inferior
, NULL
);
1959 if (new_inferior
== NULL
)
1960 error (_("Cannot remove last inferior"));
1962 set_current_inferior (new_inferior
);
1963 if (new_inferior
->pid
!= 0)
1964 tp
= any_thread_of_process (new_inferior
->pid
);
1965 switch_to_thread (tp
? tp
->ptid
: null_ptid
);
1966 set_current_program_space (new_inferior
->pspace
);
1969 delete_inferior (inf
);
1974 /* Execute a command within a safe environment.
1975 Return <0 for error; >=0 for ok.
1977 args->action will tell mi_execute_command what action
1978 to perfrom after the given command has executed (display/suppress
1979 prompt, display error). */
1982 captured_mi_execute_command (struct ui_out
*uiout
, struct mi_parse
*context
)
1984 struct cleanup
*cleanup
;
1987 current_command_ts
= context
->cmd_start
;
1989 current_token
= xstrdup (context
->token
);
1990 cleanup
= make_cleanup (free_current_contents
, ¤t_token
);
1992 running_result_record_printed
= 0;
1994 switch (context
->op
)
1997 /* A MI command was read from the input stream. */
1999 /* FIXME: gdb_???? */
2000 fprintf_unfiltered (raw_stdout
, " token=`%s' command=`%s' args=`%s'\n",
2001 context
->token
, context
->command
, context
->args
);
2003 mi_cmd_execute (context
);
2005 /* Print the result if there were no errors.
2007 Remember that on the way out of executing a command, you have
2008 to directly use the mi_interp's uiout, since the command
2009 could have reset the interpreter, in which case the current
2010 uiout will most likely crash in the mi_out_* routines. */
2011 if (!running_result_record_printed
)
2013 fputs_unfiltered (context
->token
, raw_stdout
);
2014 /* There's no particularly good reason why target-connect results
2015 in not ^done. Should kill ^connected for MI3. */
2016 fputs_unfiltered (strcmp (context
->command
, "target-select") == 0
2017 ? "^connected" : "^done", raw_stdout
);
2018 mi_out_put (uiout
, raw_stdout
);
2019 mi_out_rewind (uiout
);
2020 mi_print_timing_maybe ();
2021 fputs_unfiltered ("\n", raw_stdout
);
2024 /* The command does not want anything to be printed. In that
2025 case, the command probably should not have written anything
2026 to uiout, but in case it has written something, discard it. */
2027 mi_out_rewind (uiout
);
2034 /* A CLI command was read from the input stream. */
2035 /* This "feature" will be removed as soon as we have a
2036 complete set of mi commands. */
2037 /* Echo the command on the console. */
2038 fprintf_unfiltered (gdb_stdlog
, "%s\n", context
->command
);
2039 /* Call the "console" interpreter. */
2040 argv
[0] = "console";
2041 argv
[1] = context
->command
;
2042 mi_cmd_interpreter_exec ("-interpreter-exec", argv
, 2);
2044 /* If we changed interpreters, DON'T print out anything. */
2045 if (current_interp_named_p (INTERP_MI
)
2046 || current_interp_named_p (INTERP_MI1
)
2047 || current_interp_named_p (INTERP_MI2
)
2048 || current_interp_named_p (INTERP_MI3
))
2050 if (!running_result_record_printed
)
2052 fputs_unfiltered (context
->token
, raw_stdout
);
2053 fputs_unfiltered ("^done", raw_stdout
);
2054 mi_out_put (uiout
, raw_stdout
);
2055 mi_out_rewind (uiout
);
2056 mi_print_timing_maybe ();
2057 fputs_unfiltered ("\n", raw_stdout
);
2060 mi_out_rewind (uiout
);
2066 do_cleanups (cleanup
);
2069 /* Print a gdb exception to the MI output stream. */
2072 mi_print_exception (const char *token
, struct gdb_exception exception
)
2074 fputs_unfiltered (token
, raw_stdout
);
2075 fputs_unfiltered ("^error,msg=\"", raw_stdout
);
2076 if (exception
.message
== NULL
)
2077 fputs_unfiltered ("unknown error", raw_stdout
);
2079 fputstr_unfiltered (exception
.message
, '"', raw_stdout
);
2080 fputs_unfiltered ("\"", raw_stdout
);
2082 switch (exception
.error
)
2084 case UNDEFINED_COMMAND_ERROR
:
2085 fputs_unfiltered (",code=\"undefined-command\"", raw_stdout
);
2089 fputs_unfiltered ("\n", raw_stdout
);
2093 mi_execute_command (const char *cmd
, int from_tty
)
2096 struct mi_parse
*command
= NULL
;
2098 /* This is to handle EOF (^D). We just quit gdb. */
2099 /* FIXME: we should call some API function here. */
2101 quit_force (NULL
, from_tty
);
2103 target_log_command (cmd
);
2107 command
= mi_parse (cmd
, &token
);
2109 CATCH (exception
, RETURN_MASK_ALL
)
2111 mi_print_exception (token
, exception
);
2116 if (command
!= NULL
)
2118 ptid_t previous_ptid
= inferior_ptid
;
2120 command
->token
= token
;
2124 command
->cmd_start
= XNEW (struct mi_timestamp
);
2125 timestamp (command
->cmd_start
);
2130 captured_mi_execute_command (current_uiout
, command
);
2132 CATCH (result
, RETURN_MASK_ALL
)
2134 /* The command execution failed and error() was called
2136 mi_print_exception (command
->token
, result
);
2137 mi_out_rewind (current_uiout
);
2141 bpstat_do_actions ();
2143 if (/* The notifications are only output when the top-level
2144 interpreter (specified on the command line) is MI. */
2145 ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ()))
2146 /* Don't try report anything if there are no threads --
2147 the program is dead. */
2148 && thread_count () != 0
2149 /* -thread-select explicitly changes thread. If frontend uses that
2150 internally, we don't want to emit =thread-selected, since
2151 =thread-selected is supposed to indicate user's intentions. */
2152 && strcmp (command
->command
, "thread-select") != 0)
2154 struct mi_interp
*mi
2155 = (struct mi_interp
*) top_level_interpreter_data ();
2156 int report_change
= 0;
2158 if (command
->thread
== -1)
2160 report_change
= (!ptid_equal (previous_ptid
, null_ptid
)
2161 && !ptid_equal (inferior_ptid
, previous_ptid
)
2162 && !ptid_equal (inferior_ptid
, null_ptid
));
2164 else if (!ptid_equal (inferior_ptid
, null_ptid
))
2166 struct thread_info
*ti
= inferior_thread ();
2168 report_change
= (ti
->num
!= command
->thread
);
2173 struct thread_info
*ti
= inferior_thread ();
2175 target_terminal_ours ();
2176 fprintf_unfiltered (mi
->event_channel
,
2177 "thread-selected,id=\"%d\"",
2179 gdb_flush (mi
->event_channel
);
2183 mi_parse_free (command
);
2188 mi_cmd_execute (struct mi_parse
*parse
)
2190 struct cleanup
*cleanup
;
2191 enum language saved_language
;
2193 cleanup
= prepare_execute_command ();
2195 if (parse
->all
&& parse
->thread_group
!= -1)
2196 error (_("Cannot specify --thread-group together with --all"));
2198 if (parse
->all
&& parse
->thread
!= -1)
2199 error (_("Cannot specify --thread together with --all"));
2201 if (parse
->thread_group
!= -1 && parse
->thread
!= -1)
2202 error (_("Cannot specify --thread together with --thread-group"));
2204 if (parse
->frame
!= -1 && parse
->thread
== -1)
2205 error (_("Cannot specify --frame without --thread"));
2207 if (parse
->thread_group
!= -1)
2209 struct inferior
*inf
= find_inferior_id (parse
->thread_group
);
2210 struct thread_info
*tp
= 0;
2213 error (_("Invalid thread group for the --thread-group option"));
2215 set_current_inferior (inf
);
2216 /* This behaviour means that if --thread-group option identifies
2217 an inferior with multiple threads, then a random one will be
2218 picked. This is not a problem -- frontend should always
2219 provide --thread if it wishes to operate on a specific
2222 tp
= any_live_thread_of_process (inf
->pid
);
2223 switch_to_thread (tp
? tp
->ptid
: null_ptid
);
2224 set_current_program_space (inf
->pspace
);
2227 if (parse
->thread
!= -1)
2229 struct thread_info
*tp
= find_thread_id (parse
->thread
);
2232 error (_("Invalid thread id: %d"), parse
->thread
);
2234 if (is_exited (tp
->ptid
))
2235 error (_("Thread id: %d has terminated"), parse
->thread
);
2237 switch_to_thread (tp
->ptid
);
2240 if (parse
->frame
!= -1)
2242 struct frame_info
*fid
;
2243 int frame
= parse
->frame
;
2245 fid
= find_relative_frame (get_current_frame (), &frame
);
2247 /* find_relative_frame was successful */
2250 error (_("Invalid frame id: %d"), frame
);
2253 if (parse
->language
!= language_unknown
)
2255 make_cleanup_restore_current_language ();
2256 set_language (parse
->language
);
2259 current_context
= parse
;
2261 if (parse
->cmd
->suppress_notification
!= NULL
)
2263 make_cleanup_restore_integer (parse
->cmd
->suppress_notification
);
2264 *parse
->cmd
->suppress_notification
= 1;
2267 if (parse
->cmd
->argv_func
!= NULL
)
2269 parse
->cmd
->argv_func (parse
->command
, parse
->argv
, parse
->argc
);
2271 else if (parse
->cmd
->cli
.cmd
!= 0)
2273 /* FIXME: DELETE THIS. */
2274 /* The operation is still implemented by a cli command. */
2275 /* Must be a synchronous one. */
2276 mi_execute_cli_command (parse
->cmd
->cli
.cmd
, parse
->cmd
->cli
.args_p
,
2281 /* FIXME: DELETE THIS. */
2282 struct ui_file
*stb
;
2284 stb
= mem_fileopen ();
2286 fputs_unfiltered ("Undefined mi command: ", stb
);
2287 fputstr_unfiltered (parse
->command
, '"', stb
);
2288 fputs_unfiltered (" (missing implementation)", stb
);
2290 make_cleanup_ui_file_delete (stb
);
2293 do_cleanups (cleanup
);
2296 /* FIXME: This is just a hack so we can get some extra commands going.
2297 We don't want to channel things through the CLI, but call libgdb directly.
2298 Use only for synchronous commands. */
2301 mi_execute_cli_command (const char *cmd
, int args_p
, const char *args
)
2305 struct cleanup
*old_cleanups
;
2309 run
= xstrprintf ("%s %s", cmd
, args
);
2311 run
= xstrdup (cmd
);
2313 /* FIXME: gdb_???? */
2314 fprintf_unfiltered (gdb_stdout
, "cli=%s run=%s\n",
2316 old_cleanups
= make_cleanup (xfree
, run
);
2317 execute_command (run
, 0 /* from_tty */ );
2318 do_cleanups (old_cleanups
);
2324 mi_execute_async_cli_command (char *cli_command
, char **argv
, int argc
)
2326 struct cleanup
*old_cleanups
;
2330 run
= xstrprintf ("%s %s&", cli_command
, argc
? *argv
: "");
2332 run
= xstrprintf ("%s %s", cli_command
, argc
? *argv
: "");
2333 old_cleanups
= make_cleanup (xfree
, run
);
2335 execute_command (run
, 0 /* from_tty */ );
2337 /* Do this before doing any printing. It would appear that some
2338 print code leaves garbage around in the buffer. */
2339 do_cleanups (old_cleanups
);
2343 mi_load_progress (const char *section_name
,
2344 unsigned long sent_so_far
,
2345 unsigned long total_section
,
2346 unsigned long total_sent
,
2347 unsigned long grand_total
)
2349 struct timeval time_now
, delta
, update_threshold
;
2350 static struct timeval last_update
;
2351 static char *previous_sect_name
= NULL
;
2353 struct ui_out
*saved_uiout
;
2354 struct ui_out
*uiout
;
2356 /* This function is called through deprecated_show_load_progress
2357 which means uiout may not be correct. Fix it for the duration
2358 of this function. */
2359 saved_uiout
= current_uiout
;
2361 if (current_interp_named_p (INTERP_MI
)
2362 || current_interp_named_p (INTERP_MI2
))
2363 current_uiout
= mi_out_new (2);
2364 else if (current_interp_named_p (INTERP_MI1
))
2365 current_uiout
= mi_out_new (1);
2366 else if (current_interp_named_p (INTERP_MI3
))
2367 current_uiout
= mi_out_new (3);
2371 uiout
= current_uiout
;
2373 update_threshold
.tv_sec
= 0;
2374 update_threshold
.tv_usec
= 500000;
2375 gettimeofday (&time_now
, NULL
);
2377 delta
.tv_usec
= time_now
.tv_usec
- last_update
.tv_usec
;
2378 delta
.tv_sec
= time_now
.tv_sec
- last_update
.tv_sec
;
2380 if (delta
.tv_usec
< 0)
2383 delta
.tv_usec
+= 1000000L;
2386 new_section
= (previous_sect_name
?
2387 strcmp (previous_sect_name
, section_name
) : 1);
2390 struct cleanup
*cleanup_tuple
;
2392 xfree (previous_sect_name
);
2393 previous_sect_name
= xstrdup (section_name
);
2396 fputs_unfiltered (current_token
, raw_stdout
);
2397 fputs_unfiltered ("+download", raw_stdout
);
2398 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2399 ui_out_field_string (uiout
, "section", section_name
);
2400 ui_out_field_int (uiout
, "section-size", total_section
);
2401 ui_out_field_int (uiout
, "total-size", grand_total
);
2402 do_cleanups (cleanup_tuple
);
2403 mi_out_put (uiout
, raw_stdout
);
2404 fputs_unfiltered ("\n", raw_stdout
);
2405 gdb_flush (raw_stdout
);
2408 if (delta
.tv_sec
>= update_threshold
.tv_sec
&&
2409 delta
.tv_usec
>= update_threshold
.tv_usec
)
2411 struct cleanup
*cleanup_tuple
;
2413 last_update
.tv_sec
= time_now
.tv_sec
;
2414 last_update
.tv_usec
= time_now
.tv_usec
;
2416 fputs_unfiltered (current_token
, raw_stdout
);
2417 fputs_unfiltered ("+download", raw_stdout
);
2418 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2419 ui_out_field_string (uiout
, "section", section_name
);
2420 ui_out_field_int (uiout
, "section-sent", sent_so_far
);
2421 ui_out_field_int (uiout
, "section-size", total_section
);
2422 ui_out_field_int (uiout
, "total-sent", total_sent
);
2423 ui_out_field_int (uiout
, "total-size", grand_total
);
2424 do_cleanups (cleanup_tuple
);
2425 mi_out_put (uiout
, raw_stdout
);
2426 fputs_unfiltered ("\n", raw_stdout
);
2427 gdb_flush (raw_stdout
);
2431 current_uiout
= saved_uiout
;
2435 timestamp (struct mi_timestamp
*tv
)
2437 gettimeofday (&tv
->wallclock
, NULL
);
2438 #ifdef HAVE_GETRUSAGE
2439 getrusage (RUSAGE_SELF
, &rusage
);
2440 tv
->utime
.tv_sec
= rusage
.ru_utime
.tv_sec
;
2441 tv
->utime
.tv_usec
= rusage
.ru_utime
.tv_usec
;
2442 tv
->stime
.tv_sec
= rusage
.ru_stime
.tv_sec
;
2443 tv
->stime
.tv_usec
= rusage
.ru_stime
.tv_usec
;
2446 long usec
= get_run_time ();
2448 tv
->utime
.tv_sec
= usec
/1000000L;
2449 tv
->utime
.tv_usec
= usec
- 1000000L*tv
->utime
.tv_sec
;
2450 tv
->stime
.tv_sec
= 0;
2451 tv
->stime
.tv_usec
= 0;
2457 print_diff_now (struct mi_timestamp
*start
)
2459 struct mi_timestamp now
;
2462 print_diff (start
, &now
);
2466 mi_print_timing_maybe (void)
2468 /* If the command is -enable-timing then do_timings may be true
2469 whilst current_command_ts is not initialized. */
2470 if (do_timings
&& current_command_ts
)
2471 print_diff_now (current_command_ts
);
2475 timeval_diff (struct timeval start
, struct timeval end
)
2477 return ((end
.tv_sec
- start
.tv_sec
) * 1000000L)
2478 + (end
.tv_usec
- start
.tv_usec
);
2482 print_diff (struct mi_timestamp
*start
, struct mi_timestamp
*end
)
2486 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
2487 timeval_diff (start
->wallclock
, end
->wallclock
) / 1000000.0,
2488 timeval_diff (start
->utime
, end
->utime
) / 1000000.0,
2489 timeval_diff (start
->stime
, end
->stime
) / 1000000.0);
2493 mi_cmd_trace_define_variable (char *command
, char **argv
, int argc
)
2495 struct expression
*expr
;
2496 LONGEST initval
= 0;
2497 struct trace_state_variable
*tsv
;
2500 if (argc
!= 1 && argc
!= 2)
2501 error (_("Usage: -trace-define-variable VARIABLE [VALUE]"));
2505 error (_("Name of trace variable should start with '$'"));
2507 validate_trace_state_variable_name (name
);
2509 tsv
= find_trace_state_variable (name
);
2511 tsv
= create_trace_state_variable (name
);
2514 initval
= value_as_long (parse_and_eval (argv
[1]));
2516 tsv
->initial_value
= initval
;
2520 mi_cmd_trace_list_variables (char *command
, char **argv
, int argc
)
2523 error (_("-trace-list-variables: no arguments allowed"));
2525 tvariables_info_1 ();
2529 mi_cmd_trace_find (char *command
, char **argv
, int argc
)
2534 error (_("trace selection mode is required"));
2538 if (strcmp (mode
, "none") == 0)
2540 tfind_1 (tfind_number
, -1, 0, 0, 0);
2544 check_trace_running (current_trace_status ());
2546 if (strcmp (mode
, "frame-number") == 0)
2549 error (_("frame number is required"));
2550 tfind_1 (tfind_number
, atoi (argv
[1]), 0, 0, 0);
2552 else if (strcmp (mode
, "tracepoint-number") == 0)
2555 error (_("tracepoint number is required"));
2556 tfind_1 (tfind_tp
, atoi (argv
[1]), 0, 0, 0);
2558 else if (strcmp (mode
, "pc") == 0)
2561 error (_("PC is required"));
2562 tfind_1 (tfind_pc
, 0, parse_and_eval_address (argv
[1]), 0, 0);
2564 else if (strcmp (mode
, "pc-inside-range") == 0)
2567 error (_("Start and end PC are required"));
2568 tfind_1 (tfind_range
, 0, parse_and_eval_address (argv
[1]),
2569 parse_and_eval_address (argv
[2]), 0);
2571 else if (strcmp (mode
, "pc-outside-range") == 0)
2574 error (_("Start and end PC are required"));
2575 tfind_1 (tfind_outside
, 0, parse_and_eval_address (argv
[1]),
2576 parse_and_eval_address (argv
[2]), 0);
2578 else if (strcmp (mode
, "line") == 0)
2580 struct symtabs_and_lines sals
;
2581 struct symtab_and_line sal
;
2582 static CORE_ADDR start_pc
, end_pc
;
2583 struct cleanup
*back_to
;
2586 error (_("Line is required"));
2588 sals
= decode_line_with_current_source (argv
[1],
2589 DECODE_LINE_FUNFIRSTLINE
);
2590 back_to
= make_cleanup (xfree
, sals
.sals
);
2594 if (sal
.symtab
== 0)
2595 error (_("Could not find the specified line"));
2597 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2598 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, 0);
2600 error (_("Could not find the specified line"));
2602 do_cleanups (back_to
);
2605 error (_("Invalid mode '%s'"), mode
);
2607 if (has_stack_frames () || get_traceframe_number () >= 0)
2608 print_stack_frame (get_selected_frame (NULL
), 1, LOC_AND_ADDRESS
, 1);
2612 mi_cmd_trace_save (char *command
, char **argv
, int argc
)
2614 int target_saves
= 0;
2615 int generate_ctf
= 0;
2622 TARGET_SAVE_OPT
, CTF_OPT
2624 static const struct mi_opt opts
[] =
2626 {"r", TARGET_SAVE_OPT
, 0},
2627 {"ctf", CTF_OPT
, 0},
2633 int opt
= mi_getopt ("-trace-save", argc
, argv
, opts
,
2638 switch ((enum opt
) opt
)
2640 case TARGET_SAVE_OPT
:
2648 filename
= argv
[oind
];
2651 trace_save_ctf (filename
, target_saves
);
2653 trace_save_tfile (filename
, target_saves
);
2657 mi_cmd_trace_start (char *command
, char **argv
, int argc
)
2659 start_tracing (NULL
);
2663 mi_cmd_trace_status (char *command
, char **argv
, int argc
)
2665 trace_status_mi (0);
2669 mi_cmd_trace_stop (char *command
, char **argv
, int argc
)
2671 stop_tracing (NULL
);
2672 trace_status_mi (1);
2675 /* Implement the "-ada-task-info" command. */
2678 mi_cmd_ada_task_info (char *command
, char **argv
, int argc
)
2680 if (argc
!= 0 && argc
!= 1)
2681 error (_("Invalid MI command"));
2683 print_ada_task_info (current_uiout
, argv
[0], current_inferior ());
2686 /* Print EXPRESSION according to VALUES. */
2689 print_variable_or_computed (char *expression
, enum print_values values
)
2691 struct expression
*expr
;
2692 struct cleanup
*old_chain
;
2694 struct ui_file
*stb
;
2695 struct value_print_options opts
;
2697 struct ui_out
*uiout
= current_uiout
;
2699 stb
= mem_fileopen ();
2700 old_chain
= make_cleanup_ui_file_delete (stb
);
2702 expr
= parse_expression (expression
);
2704 make_cleanup (free_current_contents
, &expr
);
2706 if (values
== PRINT_SIMPLE_VALUES
)
2707 val
= evaluate_type (expr
);
2709 val
= evaluate_expression (expr
);
2711 if (values
!= PRINT_NO_VALUES
)
2712 make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2713 ui_out_field_string (uiout
, "name", expression
);
2717 case PRINT_SIMPLE_VALUES
:
2718 type
= check_typedef (value_type (val
));
2719 type_print (value_type (val
), "", stb
, -1);
2720 ui_out_field_stream (uiout
, "type", stb
);
2721 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
2722 && TYPE_CODE (type
) != TYPE_CODE_STRUCT
2723 && TYPE_CODE (type
) != TYPE_CODE_UNION
)
2725 struct value_print_options opts
;
2727 get_no_prettyformat_print_options (&opts
);
2729 common_val_print (val
, stb
, 0, &opts
, current_language
);
2730 ui_out_field_stream (uiout
, "value", stb
);
2733 case PRINT_ALL_VALUES
:
2735 struct value_print_options opts
;
2737 get_no_prettyformat_print_options (&opts
);
2739 common_val_print (val
, stb
, 0, &opts
, current_language
);
2740 ui_out_field_stream (uiout
, "value", stb
);
2745 do_cleanups (old_chain
);
2748 /* Implement the "-trace-frame-collected" command. */
2751 mi_cmd_trace_frame_collected (char *command
, char **argv
, int argc
)
2753 struct cleanup
*old_chain
;
2754 struct bp_location
*tloc
;
2756 struct collection_list
*clist
;
2757 struct collection_list tracepoint_list
, stepping_list
;
2758 struct traceframe_info
*tinfo
;
2760 enum print_values var_print_values
= PRINT_ALL_VALUES
;
2761 enum print_values comp_print_values
= PRINT_ALL_VALUES
;
2762 int registers_format
= 'x';
2763 int memory_contents
= 0;
2764 struct ui_out
*uiout
= current_uiout
;
2772 static const struct mi_opt opts
[] =
2774 {"-var-print-values", VAR_PRINT_VALUES
, 1},
2775 {"-comp-print-values", COMP_PRINT_VALUES
, 1},
2776 {"-registers-format", REGISTERS_FORMAT
, 1},
2777 {"-memory-contents", MEMORY_CONTENTS
, 0},
2784 int opt
= mi_getopt ("-trace-frame-collected", argc
, argv
, opts
,
2788 switch ((enum opt
) opt
)
2790 case VAR_PRINT_VALUES
:
2791 var_print_values
= mi_parse_print_values (oarg
);
2793 case COMP_PRINT_VALUES
:
2794 comp_print_values
= mi_parse_print_values (oarg
);
2796 case REGISTERS_FORMAT
:
2797 registers_format
= oarg
[0];
2798 case MEMORY_CONTENTS
:
2799 memory_contents
= 1;
2805 error (_("Usage: -trace-frame-collected "
2806 "[--var-print-values PRINT_VALUES] "
2807 "[--comp-print-values PRINT_VALUES] "
2808 "[--registers-format FORMAT]"
2809 "[--memory-contents]"));
2811 /* This throws an error is not inspecting a trace frame. */
2812 tloc
= get_traceframe_location (&stepping_frame
);
2814 /* This command only makes sense for the current frame, not the
2816 old_chain
= make_cleanup_restore_current_thread ();
2817 select_frame (get_current_frame ());
2819 encode_actions_and_make_cleanup (tloc
, &tracepoint_list
,
2823 clist
= &stepping_list
;
2825 clist
= &tracepoint_list
;
2827 tinfo
= get_traceframe_info ();
2829 /* Explicitly wholly collected variables. */
2831 struct cleanup
*list_cleanup
;
2835 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
,
2836 "explicit-variables");
2837 for (i
= 0; VEC_iterate (char_ptr
, clist
->wholly_collected
, i
, p
); i
++)
2838 print_variable_or_computed (p
, var_print_values
);
2839 do_cleanups (list_cleanup
);
2842 /* Computed expressions. */
2844 struct cleanup
*list_cleanup
;
2849 = make_cleanup_ui_out_list_begin_end (uiout
,
2850 "computed-expressions");
2851 for (i
= 0; VEC_iterate (char_ptr
, clist
->computed
, i
, p
); i
++)
2852 print_variable_or_computed (p
, comp_print_values
);
2853 do_cleanups (list_cleanup
);
2856 /* Registers. Given pseudo-registers, and that some architectures
2857 (like MIPS) actually hide the raw registers, we don't go through
2858 the trace frame info, but instead consult the register cache for
2859 register availability. */
2861 struct cleanup
*list_cleanup
;
2862 struct frame_info
*frame
;
2863 struct gdbarch
*gdbarch
;
2867 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "registers");
2869 frame
= get_selected_frame (NULL
);
2870 gdbarch
= get_frame_arch (frame
);
2871 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
2873 for (regnum
= 0; regnum
< numregs
; regnum
++)
2875 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
2876 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
2879 output_register (frame
, regnum
, registers_format
, 1);
2882 do_cleanups (list_cleanup
);
2885 /* Trace state variables. */
2887 struct cleanup
*list_cleanup
;
2892 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "tvars");
2895 make_cleanup (free_current_contents
, &tsvname
);
2897 for (i
= 0; VEC_iterate (int, tinfo
->tvars
, i
, tvar
); i
++)
2899 struct cleanup
*cleanup_child
;
2900 struct trace_state_variable
*tsv
;
2902 tsv
= find_trace_state_variable_by_number (tvar
);
2904 cleanup_child
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2908 tsvname
= (char *) xrealloc (tsvname
, strlen (tsv
->name
) + 2);
2910 strcpy (tsvname
+ 1, tsv
->name
);
2911 ui_out_field_string (uiout
, "name", tsvname
);
2913 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
2915 ui_out_field_int (uiout
, "current", tsv
->value
);
2919 ui_out_field_skip (uiout
, "name");
2920 ui_out_field_skip (uiout
, "current");
2923 do_cleanups (cleanup_child
);
2926 do_cleanups (list_cleanup
);
2931 struct cleanup
*list_cleanup
;
2932 VEC(mem_range_s
) *available_memory
= NULL
;
2933 struct mem_range
*r
;
2936 traceframe_available_memory (&available_memory
, 0, ULONGEST_MAX
);
2937 make_cleanup (VEC_cleanup(mem_range_s
), &available_memory
);
2939 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "memory");
2941 for (i
= 0; VEC_iterate (mem_range_s
, available_memory
, i
, r
); i
++)
2943 struct cleanup
*cleanup_child
;
2945 struct gdbarch
*gdbarch
= target_gdbarch ();
2947 cleanup_child
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2949 ui_out_field_core_addr (uiout
, "address", gdbarch
, r
->start
);
2950 ui_out_field_int (uiout
, "length", r
->length
);
2952 data
= (gdb_byte
*) xmalloc (r
->length
);
2953 make_cleanup (xfree
, data
);
2955 if (memory_contents
)
2957 if (target_read_memory (r
->start
, data
, r
->length
) == 0)
2962 data_str
= (char *) xmalloc (r
->length
* 2 + 1);
2963 make_cleanup (xfree
, data_str
);
2965 for (m
= 0, p
= data_str
; m
< r
->length
; ++m
, p
+= 2)
2966 sprintf (p
, "%02x", data
[m
]);
2967 ui_out_field_string (uiout
, "contents", data_str
);
2970 ui_out_field_skip (uiout
, "contents");
2972 do_cleanups (cleanup_child
);
2975 do_cleanups (list_cleanup
);
2978 do_cleanups (old_chain
);
2982 _initialize_mi_main (void)
2984 struct cmd_list_element
*c
;
2986 add_setshow_boolean_cmd ("mi-async", class_run
,
2988 Set whether MI asynchronous mode is enabled."), _("\
2989 Show whether MI asynchronous mode is enabled."), _("\
2990 Tells GDB whether MI should be in asynchronous mode."),
2991 set_mi_async_command
,
2992 show_mi_async_command
,
2996 /* Alias old "target-async" to "mi-async". */
2997 c
= add_alias_cmd ("target-async", "mi-async", class_run
, 0, &setlist
);
2998 deprecate_cmd (c
, "set mi-async");
2999 c
= add_alias_cmd ("target-async", "mi-async", class_run
, 0, &showlist
);
3000 deprecate_cmd (c
, "show mi-async");