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";
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
)
448 /* Parse the command options. */
453 static const struct mi_opt opts
[] =
455 {"-start", START_OPT
, 0},
464 int opt
= mi_getopt ("-exec-run", argc
, argv
, opts
, &oind
, &oarg
);
468 switch ((enum opt
) opt
)
476 /* This command does not accept any argument. Make sure the user
477 did not provide any. */
479 error (_("Invalid argument: %s"), argv
[oind
]);
481 if (current_context
->all
)
483 struct cleanup
*back_to
= save_current_space_and_thread ();
485 iterate_over_inferiors (run_one_inferior
, &start_p
);
486 do_cleanups (back_to
);
490 const char *run_cmd
= start_p
? "start" : "run";
492 mi_execute_cli_command (run_cmd
, mi_async_p (),
493 mi_async_p () ? "&" : NULL
);
499 find_thread_of_process (struct thread_info
*ti
, void *p
)
503 if (ptid_get_pid (ti
->ptid
) == pid
&& !is_exited (ti
->ptid
))
510 mi_cmd_target_detach (char *command
, char **argv
, int argc
)
512 if (argc
!= 0 && argc
!= 1)
513 error (_("Usage: -target-detach [pid | thread-group]"));
517 struct thread_info
*tp
;
521 /* First see if we are dealing with a thread-group id. */
524 struct inferior
*inf
;
525 int id
= strtoul (argv
[0] + 1, &end
, 0);
528 error (_("Invalid syntax of thread-group id '%s'"), argv
[0]);
530 inf
= find_inferior_id (id
);
532 error (_("Non-existent thread-group id '%d'"), id
);
538 /* We must be dealing with a pid. */
539 pid
= strtol (argv
[0], &end
, 10);
542 error (_("Invalid identifier '%s'"), argv
[0]);
545 /* Pick any thread in the desired process. Current
546 target_detach detaches from the parent of inferior_ptid. */
547 tp
= iterate_over_threads (find_thread_of_process
, &pid
);
549 error (_("Thread group is empty"));
551 switch_to_thread (tp
->ptid
);
554 detach_command (NULL
, 0);
558 mi_cmd_thread_select (char *command
, char **argv
, int argc
)
561 char *mi_error_message
;
564 error (_("-thread-select: USAGE: threadnum."));
566 rc
= gdb_thread_select (current_uiout
, argv
[0], &mi_error_message
);
568 if (rc
== GDB_RC_FAIL
)
570 make_cleanup (xfree
, mi_error_message
);
571 error ("%s", mi_error_message
);
576 mi_cmd_thread_list_ids (char *command
, char **argv
, int argc
)
579 char *mi_error_message
;
582 error (_("-thread-list-ids: No arguments required."));
584 rc
= gdb_list_thread_ids (current_uiout
, &mi_error_message
);
586 if (rc
== GDB_RC_FAIL
)
588 make_cleanup (xfree
, mi_error_message
);
589 error ("%s", mi_error_message
);
594 mi_cmd_thread_info (char *command
, char **argv
, int argc
)
596 if (argc
!= 0 && argc
!= 1)
597 error (_("Invalid MI command"));
599 print_thread_info (current_uiout
, argv
[0], -1);
602 struct collect_cores_data
610 collect_cores (struct thread_info
*ti
, void *xdata
)
612 struct collect_cores_data
*data
= (struct collect_cores_data
*) xdata
;
614 if (ptid_get_pid (ti
->ptid
) == data
->pid
)
616 int core
= target_core_of_thread (ti
->ptid
);
619 VEC_safe_push (int, data
->cores
, core
);
626 unique (int *b
, int *e
)
636 struct print_one_inferior_data
639 VEC (int) *inferiors
;
643 print_one_inferior (struct inferior
*inferior
, void *xdata
)
645 struct print_one_inferior_data
*top_data
646 = (struct print_one_inferior_data
*) xdata
;
647 struct ui_out
*uiout
= current_uiout
;
649 if (VEC_empty (int, top_data
->inferiors
)
650 || bsearch (&(inferior
->pid
), VEC_address (int, top_data
->inferiors
),
651 VEC_length (int, top_data
->inferiors
), sizeof (int),
652 compare_positive_ints
))
654 struct collect_cores_data data
;
655 struct cleanup
*back_to
656 = make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
658 ui_out_field_fmt (uiout
, "id", "i%d", inferior
->num
);
659 ui_out_field_string (uiout
, "type", "process");
660 if (inferior
->has_exit_code
)
661 ui_out_field_string (uiout
, "exit-code",
662 int_string (inferior
->exit_code
, 8, 0, 0, 1));
663 if (inferior
->pid
!= 0)
664 ui_out_field_int (uiout
, "pid", inferior
->pid
);
666 if (inferior
->pspace
->pspace_exec_filename
!= NULL
)
668 ui_out_field_string (uiout
, "executable",
669 inferior
->pspace
->pspace_exec_filename
);
673 if (inferior
->pid
!= 0)
675 data
.pid
= inferior
->pid
;
676 iterate_over_threads (collect_cores
, &data
);
679 if (!VEC_empty (int, data
.cores
))
682 struct cleanup
*back_to_2
=
683 make_cleanup_ui_out_list_begin_end (uiout
, "cores");
685 qsort (VEC_address (int, data
.cores
),
686 VEC_length (int, data
.cores
), sizeof (int),
687 compare_positive_ints
);
689 b
= VEC_address (int, data
.cores
);
690 e
= b
+ VEC_length (int, data
.cores
);
694 ui_out_field_int (uiout
, NULL
, *b
);
696 do_cleanups (back_to_2
);
699 if (top_data
->recurse
)
700 print_thread_info (uiout
, NULL
, inferior
->pid
);
702 do_cleanups (back_to
);
708 /* Output a field named 'cores' with a list as the value. The
709 elements of the list are obtained by splitting 'cores' on
713 output_cores (struct ui_out
*uiout
, const char *field_name
, const char *xcores
)
715 struct cleanup
*back_to
= make_cleanup_ui_out_list_begin_end (uiout
,
717 char *cores
= xstrdup (xcores
);
720 make_cleanup (xfree
, cores
);
722 for (p
= strtok (p
, ","); p
; p
= strtok (NULL
, ","))
723 ui_out_field_string (uiout
, NULL
, p
);
725 do_cleanups (back_to
);
729 free_vector_of_ints (void *xvector
)
731 VEC (int) **vector
= (VEC (int) **) xvector
;
733 VEC_free (int, *vector
);
737 do_nothing (splay_tree_key k
)
742 free_vector_of_osdata_items (splay_tree_value xvalue
)
744 VEC (osdata_item_s
) *value
= (VEC (osdata_item_s
) *) xvalue
;
746 /* We don't free the items itself, it will be done separately. */
747 VEC_free (osdata_item_s
, value
);
751 splay_tree_int_comparator (splay_tree_key xa
, splay_tree_key xb
)
760 free_splay_tree (void *xt
)
762 splay_tree t
= (splay_tree
) xt
;
763 splay_tree_delete (t
);
767 list_available_thread_groups (VEC (int) *ids
, int recurse
)
770 struct osdata_item
*item
;
772 struct ui_out
*uiout
= current_uiout
;
773 struct cleanup
*cleanup
;
775 /* This keeps a map from integer (pid) to VEC (struct osdata_item *)*
776 The vector contains information about all threads for the given pid.
777 This is assigned an initial value to avoid "may be used uninitialized"
779 splay_tree tree
= NULL
;
781 /* get_osdata will throw if it cannot return data. */
782 data
= get_osdata ("processes");
783 cleanup
= make_cleanup_osdata_free (data
);
787 struct osdata
*threads
= get_osdata ("threads");
789 make_cleanup_osdata_free (threads
);
790 tree
= splay_tree_new (splay_tree_int_comparator
,
792 free_vector_of_osdata_items
);
793 make_cleanup (free_splay_tree
, tree
);
796 VEC_iterate (osdata_item_s
, threads
->items
,
800 const char *pid
= get_osdata_column (item
, "pid");
801 int pid_i
= strtoul (pid
, NULL
, 0);
802 VEC (osdata_item_s
) *vec
= 0;
804 splay_tree_node n
= splay_tree_lookup (tree
, pid_i
);
807 VEC_safe_push (osdata_item_s
, vec
, item
);
808 splay_tree_insert (tree
, pid_i
, (splay_tree_value
)vec
);
812 vec
= (VEC (osdata_item_s
) *) n
->value
;
813 VEC_safe_push (osdata_item_s
, vec
, item
);
814 n
->value
= (splay_tree_value
) vec
;
819 make_cleanup_ui_out_list_begin_end (uiout
, "groups");
822 VEC_iterate (osdata_item_s
, data
->items
,
826 struct cleanup
*back_to
;
828 const char *pid
= get_osdata_column (item
, "pid");
829 const char *cmd
= get_osdata_column (item
, "command");
830 const char *user
= get_osdata_column (item
, "user");
831 const char *cores
= get_osdata_column (item
, "cores");
833 int pid_i
= strtoul (pid
, NULL
, 0);
835 /* At present, the target will return all available processes
836 and if information about specific ones was required, we filter
837 undesired processes here. */
838 if (ids
&& bsearch (&pid_i
, VEC_address (int, ids
),
839 VEC_length (int, ids
),
840 sizeof (int), compare_positive_ints
) == NULL
)
844 back_to
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
846 ui_out_field_fmt (uiout
, "id", "%s", pid
);
847 ui_out_field_string (uiout
, "type", "process");
849 ui_out_field_string (uiout
, "description", cmd
);
851 ui_out_field_string (uiout
, "user", user
);
853 output_cores (uiout
, "cores", cores
);
857 splay_tree_node n
= splay_tree_lookup (tree
, pid_i
);
860 VEC (osdata_item_s
) *children
= (VEC (osdata_item_s
) *) n
->value
;
861 struct osdata_item
*child
;
864 make_cleanup_ui_out_list_begin_end (uiout
, "threads");
867 VEC_iterate (osdata_item_s
, children
, ix_child
, child
);
870 struct cleanup
*back_to_2
=
871 make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
872 const char *tid
= get_osdata_column (child
, "tid");
873 const char *tcore
= get_osdata_column (child
, "core");
875 ui_out_field_string (uiout
, "id", tid
);
877 ui_out_field_string (uiout
, "core", tcore
);
879 do_cleanups (back_to_2
);
884 do_cleanups (back_to
);
887 do_cleanups (cleanup
);
891 mi_cmd_list_thread_groups (char *command
, char **argv
, int argc
)
893 struct ui_out
*uiout
= current_uiout
;
894 struct cleanup
*back_to
;
901 AVAILABLE_OPT
, RECURSE_OPT
903 static const struct mi_opt opts
[] =
905 {"-available", AVAILABLE_OPT
, 0},
906 {"-recurse", RECURSE_OPT
, 1},
915 int opt
= mi_getopt ("-list-thread-groups", argc
, argv
, opts
,
920 switch ((enum opt
) opt
)
926 if (strcmp (oarg
, "0") == 0)
928 else if (strcmp (oarg
, "1") == 0)
931 error (_("only '0' and '1' are valid values "
932 "for the '--recurse' option"));
937 for (; oind
< argc
; ++oind
)
942 if (*(argv
[oind
]) != 'i')
943 error (_("invalid syntax of group id '%s'"), argv
[oind
]);
945 inf
= strtoul (argv
[oind
] + 1, &end
, 0);
948 error (_("invalid syntax of group id '%s'"), argv
[oind
]);
949 VEC_safe_push (int, ids
, inf
);
951 if (VEC_length (int, ids
) > 1)
952 qsort (VEC_address (int, ids
),
953 VEC_length (int, ids
),
954 sizeof (int), compare_positive_ints
);
956 back_to
= make_cleanup (free_vector_of_ints
, &ids
);
960 list_available_thread_groups (ids
, recurse
);
962 else if (VEC_length (int, ids
) == 1)
964 /* Local thread groups, single id. */
965 int id
= *VEC_address (int, ids
);
966 struct inferior
*inf
= find_inferior_id (id
);
969 error (_("Non-existent thread group id '%d'"), id
);
971 print_thread_info (uiout
, NULL
, inf
->pid
);
975 struct print_one_inferior_data data
;
977 data
.recurse
= recurse
;
978 data
.inferiors
= ids
;
980 /* Local thread groups. Either no explicit ids -- and we
981 print everything, or several explicit ids. In both cases,
982 we print more than one group, and have to use 'groups'
983 as the top-level element. */
984 make_cleanup_ui_out_list_begin_end (uiout
, "groups");
985 update_thread_list ();
986 iterate_over_inferiors (print_one_inferior
, &data
);
989 do_cleanups (back_to
);
993 mi_cmd_data_list_register_names (char *command
, char **argv
, int argc
)
995 struct gdbarch
*gdbarch
;
996 struct ui_out
*uiout
= current_uiout
;
999 struct cleanup
*cleanup
;
1001 /* Note that the test for a valid register must include checking the
1002 gdbarch_register_name because gdbarch_num_regs may be allocated
1003 for the union of the register sets within a family of related
1004 processors. In this case, some entries of gdbarch_register_name
1005 will change depending upon the particular processor being
1008 gdbarch
= get_current_arch ();
1009 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1011 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "register-names");
1013 if (argc
== 0) /* No args, just do all the regs. */
1019 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1020 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1021 ui_out_field_string (uiout
, NULL
, "");
1023 ui_out_field_string (uiout
, NULL
,
1024 gdbarch_register_name (gdbarch
, regnum
));
1028 /* Else, list of register #s, just do listed regs. */
1029 for (i
= 0; i
< argc
; i
++)
1031 regnum
= atoi (argv
[i
]);
1032 if (regnum
< 0 || regnum
>= numregs
)
1033 error (_("bad register number"));
1035 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1036 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1037 ui_out_field_string (uiout
, NULL
, "");
1039 ui_out_field_string (uiout
, NULL
,
1040 gdbarch_register_name (gdbarch
, regnum
));
1042 do_cleanups (cleanup
);
1046 mi_cmd_data_list_changed_registers (char *command
, char **argv
, int argc
)
1048 static struct regcache
*this_regs
= NULL
;
1049 struct ui_out
*uiout
= current_uiout
;
1050 struct regcache
*prev_regs
;
1051 struct gdbarch
*gdbarch
;
1052 int regnum
, numregs
, changed
;
1054 struct cleanup
*cleanup
;
1056 /* The last time we visited this function, the current frame's
1057 register contents were saved in THIS_REGS. Move THIS_REGS over
1058 to PREV_REGS, and refresh THIS_REGS with the now-current register
1061 prev_regs
= this_regs
;
1062 this_regs
= frame_save_as_regcache (get_selected_frame (NULL
));
1063 cleanup
= make_cleanup_regcache_xfree (prev_regs
);
1065 /* Note that the test for a valid register must include checking the
1066 gdbarch_register_name because gdbarch_num_regs may be allocated
1067 for the union of the register sets within a family of related
1068 processors. In this case, some entries of gdbarch_register_name
1069 will change depending upon the particular processor being
1072 gdbarch
= get_regcache_arch (this_regs
);
1073 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1075 make_cleanup_ui_out_list_begin_end (uiout
, "changed-registers");
1079 /* No args, just do all the regs. */
1084 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1085 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1087 changed
= register_changed_p (regnum
, prev_regs
, this_regs
);
1089 error (_("-data-list-changed-registers: "
1090 "Unable to read register contents."));
1092 ui_out_field_int (uiout
, NULL
, regnum
);
1096 /* Else, list of register #s, just do listed regs. */
1097 for (i
= 0; i
< argc
; i
++)
1099 regnum
= atoi (argv
[i
]);
1103 && gdbarch_register_name (gdbarch
, regnum
) != NULL
1104 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
1106 changed
= register_changed_p (regnum
, prev_regs
, this_regs
);
1108 error (_("-data-list-changed-registers: "
1109 "Unable to read register contents."));
1111 ui_out_field_int (uiout
, NULL
, regnum
);
1114 error (_("bad register number"));
1116 do_cleanups (cleanup
);
1120 register_changed_p (int regnum
, struct regcache
*prev_regs
,
1121 struct regcache
*this_regs
)
1123 struct gdbarch
*gdbarch
= get_regcache_arch (this_regs
);
1124 gdb_byte prev_buffer
[MAX_REGISTER_SIZE
];
1125 gdb_byte this_buffer
[MAX_REGISTER_SIZE
];
1126 enum register_status prev_status
;
1127 enum register_status this_status
;
1129 /* First time through or after gdbarch change consider all registers
1131 if (!prev_regs
|| get_regcache_arch (prev_regs
) != gdbarch
)
1134 /* Get register contents and compare. */
1135 prev_status
= regcache_cooked_read (prev_regs
, regnum
, prev_buffer
);
1136 this_status
= regcache_cooked_read (this_regs
, regnum
, this_buffer
);
1138 if (this_status
!= prev_status
)
1140 else if (this_status
== REG_VALID
)
1141 return memcmp (prev_buffer
, this_buffer
,
1142 register_size (gdbarch
, regnum
)) != 0;
1147 /* Return a list of register number and value pairs. The valid
1148 arguments expected are: a letter indicating the format in which to
1149 display the registers contents. This can be one of: x
1150 (hexadecimal), d (decimal), N (natural), t (binary), o (octal), r
1151 (raw). After the format argument there can be a sequence of
1152 numbers, indicating which registers to fetch the content of. If
1153 the format is the only argument, a list of all the registers with
1154 their values is returned. */
1157 mi_cmd_data_list_register_values (char *command
, char **argv
, int argc
)
1159 struct ui_out
*uiout
= current_uiout
;
1160 struct frame_info
*frame
;
1161 struct gdbarch
*gdbarch
;
1162 int regnum
, numregs
, format
;
1164 struct cleanup
*list_cleanup
;
1165 int skip_unavailable
= 0;
1171 static const struct mi_opt opts
[] =
1173 {"-skip-unavailable", SKIP_UNAVAILABLE
, 0},
1177 /* Note that the test for a valid register must include checking the
1178 gdbarch_register_name because gdbarch_num_regs may be allocated
1179 for the union of the register sets within a family of related
1180 processors. In this case, some entries of gdbarch_register_name
1181 will change depending upon the particular processor being
1187 int opt
= mi_getopt ("-data-list-register-values", argc
, argv
,
1188 opts
, &oind
, &oarg
);
1192 switch ((enum opt
) opt
)
1194 case SKIP_UNAVAILABLE
:
1195 skip_unavailable
= 1;
1200 if (argc
- oind
< 1)
1201 error (_("-data-list-register-values: Usage: "
1202 "-data-list-register-values [--skip-unavailable] <format>"
1203 " [<regnum1>...<regnumN>]"));
1205 format
= (int) argv
[oind
][0];
1207 frame
= get_selected_frame (NULL
);
1208 gdbarch
= get_frame_arch (frame
);
1209 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1211 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "register-values");
1213 if (argc
- oind
== 1)
1215 /* No args, beside the format: do all the regs. */
1220 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1221 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1224 output_register (frame
, regnum
, format
, skip_unavailable
);
1228 /* Else, list of register #s, just do listed regs. */
1229 for (i
= 1 + oind
; i
< argc
; i
++)
1231 regnum
= atoi (argv
[i
]);
1235 && gdbarch_register_name (gdbarch
, regnum
) != NULL
1236 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
1237 output_register (frame
, regnum
, format
, skip_unavailable
);
1239 error (_("bad register number"));
1241 do_cleanups (list_cleanup
);
1244 /* Output one register REGNUM's contents in the desired FORMAT. If
1245 SKIP_UNAVAILABLE is true, skip the register if it is
1249 output_register (struct frame_info
*frame
, int regnum
, int format
,
1250 int skip_unavailable
)
1252 struct ui_out
*uiout
= current_uiout
;
1253 struct value
*val
= value_of_register (regnum
, frame
);
1254 struct cleanup
*tuple_cleanup
;
1255 struct value_print_options opts
;
1256 struct ui_file
*stb
;
1258 if (skip_unavailable
&& !value_entirely_available (val
))
1261 tuple_cleanup
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1262 ui_out_field_int (uiout
, "number", regnum
);
1270 stb
= mem_fileopen ();
1271 make_cleanup_ui_file_delete (stb
);
1273 get_formatted_print_options (&opts
, format
);
1275 val_print (value_type (val
),
1276 value_contents_for_printing (val
),
1277 value_embedded_offset (val
), 0,
1278 stb
, 0, val
, &opts
, current_language
);
1279 ui_out_field_stream (uiout
, "value", stb
);
1281 do_cleanups (tuple_cleanup
);
1284 /* Write given values into registers. The registers and values are
1285 given as pairs. The corresponding MI command is
1286 -data-write-register-values <format>
1287 [<regnum1> <value1>...<regnumN> <valueN>] */
1289 mi_cmd_data_write_register_values (char *command
, char **argv
, int argc
)
1291 struct regcache
*regcache
;
1292 struct gdbarch
*gdbarch
;
1295 /* Note that the test for a valid register must include checking the
1296 gdbarch_register_name because gdbarch_num_regs may be allocated
1297 for the union of the register sets within a family of related
1298 processors. In this case, some entries of gdbarch_register_name
1299 will change depending upon the particular processor being
1302 regcache
= get_current_regcache ();
1303 gdbarch
= get_regcache_arch (regcache
);
1304 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1307 error (_("-data-write-register-values: Usage: -data-write-register-"
1308 "values <format> [<regnum1> <value1>...<regnumN> <valueN>]"));
1310 if (!target_has_registers
)
1311 error (_("-data-write-register-values: No registers."));
1314 error (_("-data-write-register-values: No regs and values specified."));
1317 error (_("-data-write-register-values: "
1318 "Regs and vals are not in pairs."));
1320 for (i
= 1; i
< argc
; i
= i
+ 2)
1322 int regnum
= atoi (argv
[i
]);
1324 if (regnum
>= 0 && regnum
< numregs
1325 && gdbarch_register_name (gdbarch
, regnum
)
1326 && *gdbarch_register_name (gdbarch
, regnum
))
1330 /* Get the value as a number. */
1331 value
= parse_and_eval_address (argv
[i
+ 1]);
1333 /* Write it down. */
1334 regcache_cooked_write_signed (regcache
, regnum
, value
);
1337 error (_("bad register number"));
1341 /* Evaluate the value of the argument. The argument is an
1342 expression. If the expression contains spaces it needs to be
1343 included in double quotes. */
1346 mi_cmd_data_evaluate_expression (char *command
, char **argv
, int argc
)
1348 struct expression
*expr
;
1349 struct cleanup
*old_chain
;
1351 struct ui_file
*stb
;
1352 struct value_print_options opts
;
1353 struct ui_out
*uiout
= current_uiout
;
1355 stb
= mem_fileopen ();
1356 old_chain
= make_cleanup_ui_file_delete (stb
);
1359 error (_("-data-evaluate-expression: "
1360 "Usage: -data-evaluate-expression expression"));
1362 expr
= parse_expression (argv
[0]);
1364 make_cleanup (free_current_contents
, &expr
);
1366 val
= evaluate_expression (expr
);
1368 /* Print the result of the expression evaluation. */
1369 get_user_print_options (&opts
);
1371 common_val_print (val
, stb
, 0, &opts
, current_language
);
1373 ui_out_field_stream (uiout
, "value", stb
);
1375 do_cleanups (old_chain
);
1378 /* This is the -data-read-memory command.
1380 ADDR: start address of data to be dumped.
1381 WORD-FORMAT: a char indicating format for the ``word''. See
1383 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
1384 NR_ROW: Number of rows.
1385 NR_COL: The number of colums (words per row).
1386 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
1387 ASCHAR for unprintable characters.
1389 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
1390 displayes them. Returns:
1392 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
1395 The number of bytes read is SIZE*ROW*COL. */
1398 mi_cmd_data_read_memory (char *command
, char **argv
, int argc
)
1400 struct gdbarch
*gdbarch
= get_current_arch ();
1401 struct ui_out
*uiout
= current_uiout
;
1402 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
1404 long total_bytes
, nr_cols
, nr_rows
;
1406 struct type
*word_type
;
1419 static const struct mi_opt opts
[] =
1421 {"o", OFFSET_OPT
, 1},
1427 int opt
= mi_getopt ("-data-read-memory", argc
, argv
, opts
,
1432 switch ((enum opt
) opt
)
1435 offset
= atol (oarg
);
1442 if (argc
< 5 || argc
> 6)
1443 error (_("-data-read-memory: Usage: "
1444 "ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR]."));
1446 /* Extract all the arguments. */
1448 /* Start address of the memory dump. */
1449 addr
= parse_and_eval_address (argv
[0]) + offset
;
1450 /* The format character to use when displaying a memory word. See
1451 the ``x'' command. */
1452 word_format
= argv
[1][0];
1453 /* The size of the memory word. */
1454 word_size
= atol (argv
[2]);
1458 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1462 word_type
= builtin_type (gdbarch
)->builtin_int16
;
1466 word_type
= builtin_type (gdbarch
)->builtin_int32
;
1470 word_type
= builtin_type (gdbarch
)->builtin_int64
;
1474 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1477 /* The number of rows. */
1478 nr_rows
= atol (argv
[3]);
1480 error (_("-data-read-memory: invalid number of rows."));
1482 /* Number of bytes per row. */
1483 nr_cols
= atol (argv
[4]);
1485 error (_("-data-read-memory: invalid number of columns."));
1487 /* The un-printable character when printing ascii. */
1493 /* Create a buffer and read it in. */
1494 total_bytes
= word_size
* nr_rows
* nr_cols
;
1495 mbuf
= XCNEWVEC (gdb_byte
, total_bytes
);
1496 make_cleanup (xfree
, mbuf
);
1498 /* Dispatch memory reads to the topmost target, not the flattened
1500 nr_bytes
= target_read (current_target
.beneath
,
1501 TARGET_OBJECT_MEMORY
, NULL
, mbuf
,
1504 error (_("Unable to read memory."));
1506 /* Output the header information. */
1507 ui_out_field_core_addr (uiout
, "addr", gdbarch
, addr
);
1508 ui_out_field_int (uiout
, "nr-bytes", nr_bytes
);
1509 ui_out_field_int (uiout
, "total-bytes", total_bytes
);
1510 ui_out_field_core_addr (uiout
, "next-row",
1511 gdbarch
, addr
+ word_size
* nr_cols
);
1512 ui_out_field_core_addr (uiout
, "prev-row",
1513 gdbarch
, addr
- word_size
* nr_cols
);
1514 ui_out_field_core_addr (uiout
, "next-page", gdbarch
, addr
+ total_bytes
);
1515 ui_out_field_core_addr (uiout
, "prev-page", gdbarch
, addr
- total_bytes
);
1517 /* Build the result as a two dimentional table. */
1519 struct ui_file
*stream
;
1520 struct cleanup
*cleanup_stream
;
1524 stream
= mem_fileopen ();
1525 cleanup_stream
= make_cleanup_ui_file_delete (stream
);
1527 make_cleanup_ui_out_list_begin_end (uiout
, "memory");
1528 for (row
= 0, row_byte
= 0;
1530 row
++, row_byte
+= nr_cols
* word_size
)
1534 struct cleanup
*cleanup_tuple
;
1535 struct cleanup
*cleanup_list_data
;
1536 struct value_print_options opts
;
1538 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1539 ui_out_field_core_addr (uiout
, "addr", gdbarch
, addr
+ row_byte
);
1540 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr +
1542 cleanup_list_data
= make_cleanup_ui_out_list_begin_end (uiout
, "data");
1543 get_formatted_print_options (&opts
, word_format
);
1544 for (col
= 0, col_byte
= row_byte
;
1546 col
++, col_byte
+= word_size
)
1548 if (col_byte
+ word_size
> nr_bytes
)
1550 ui_out_field_string (uiout
, NULL
, "N/A");
1554 ui_file_rewind (stream
);
1555 print_scalar_formatted (mbuf
+ col_byte
, word_type
, &opts
,
1556 word_asize
, stream
);
1557 ui_out_field_stream (uiout
, NULL
, stream
);
1560 do_cleanups (cleanup_list_data
);
1565 ui_file_rewind (stream
);
1566 for (byte
= row_byte
;
1567 byte
< row_byte
+ word_size
* nr_cols
; byte
++)
1569 if (byte
>= nr_bytes
)
1570 fputc_unfiltered ('X', stream
);
1571 else if (mbuf
[byte
] < 32 || mbuf
[byte
] > 126)
1572 fputc_unfiltered (aschar
, stream
);
1574 fputc_unfiltered (mbuf
[byte
], stream
);
1576 ui_out_field_stream (uiout
, "ascii", stream
);
1578 do_cleanups (cleanup_tuple
);
1580 do_cleanups (cleanup_stream
);
1582 do_cleanups (cleanups
);
1586 mi_cmd_data_read_memory_bytes (char *command
, char **argv
, int argc
)
1588 struct gdbarch
*gdbarch
= get_current_arch ();
1589 struct ui_out
*uiout
= current_uiout
;
1590 struct cleanup
*cleanups
;
1593 memory_read_result_s
*read_result
;
1595 VEC(memory_read_result_s
) *result
;
1597 int unit_size
= gdbarch_addressable_memory_unit_size (gdbarch
);
1604 static const struct mi_opt opts
[] =
1606 {"o", OFFSET_OPT
, 1},
1612 int opt
= mi_getopt ("-data-read-memory-bytes", argc
, argv
, opts
,
1616 switch ((enum opt
) opt
)
1619 offset
= atol (oarg
);
1627 error (_("Usage: [ -o OFFSET ] ADDR LENGTH."));
1629 addr
= parse_and_eval_address (argv
[0]) + offset
;
1630 length
= atol (argv
[1]);
1632 result
= read_memory_robust (current_target
.beneath
, addr
, length
);
1634 cleanups
= make_cleanup (free_memory_read_result_vector
, result
);
1636 if (VEC_length (memory_read_result_s
, result
) == 0)
1637 error (_("Unable to read memory."));
1639 make_cleanup_ui_out_list_begin_end (uiout
, "memory");
1641 VEC_iterate (memory_read_result_s
, result
, ix
, read_result
);
1644 struct cleanup
*t
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1649 ui_out_field_core_addr (uiout
, "begin", gdbarch
, read_result
->begin
);
1650 ui_out_field_core_addr (uiout
, "offset", gdbarch
, read_result
->begin
1652 ui_out_field_core_addr (uiout
, "end", gdbarch
, read_result
->end
);
1654 alloc_len
= (read_result
->end
- read_result
->begin
) * 2 * unit_size
+ 1;
1655 data
= (char *) xmalloc (alloc_len
);
1657 for (i
= 0, p
= data
;
1658 i
< ((read_result
->end
- read_result
->begin
) * unit_size
);
1661 sprintf (p
, "%02x", read_result
->data
[i
]);
1663 ui_out_field_string (uiout
, "contents", data
);
1667 do_cleanups (cleanups
);
1670 /* Implementation of the -data-write_memory command.
1672 COLUMN_OFFSET: optional argument. Must be preceded by '-o'. The
1673 offset from the beginning of the memory grid row where the cell to
1675 ADDR: start address of the row in the memory grid where the memory
1676 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
1677 the location to write to.
1678 FORMAT: a char indicating format for the ``word''. See
1680 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
1681 VALUE: value to be written into the memory address.
1683 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1688 mi_cmd_data_write_memory (char *command
, char **argv
, int argc
)
1690 struct gdbarch
*gdbarch
= get_current_arch ();
1691 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1694 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1695 enough when using a compiler other than GCC. */
1698 struct cleanup
*old_chain
;
1706 static const struct mi_opt opts
[] =
1708 {"o", OFFSET_OPT
, 1},
1714 int opt
= mi_getopt ("-data-write-memory", argc
, argv
, opts
,
1719 switch ((enum opt
) opt
)
1722 offset
= atol (oarg
);
1730 error (_("-data-write-memory: Usage: "
1731 "[-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE."));
1733 /* Extract all the arguments. */
1734 /* Start address of the memory dump. */
1735 addr
= parse_and_eval_address (argv
[0]);
1736 /* The size of the memory word. */
1737 word_size
= atol (argv
[2]);
1739 /* Calculate the real address of the write destination. */
1740 addr
+= (offset
* word_size
);
1742 /* Get the value as a number. */
1743 value
= parse_and_eval_address (argv
[3]);
1744 /* Get the value into an array. */
1745 buffer
= (gdb_byte
*) xmalloc (word_size
);
1746 old_chain
= make_cleanup (xfree
, buffer
);
1747 store_signed_integer (buffer
, word_size
, byte_order
, value
);
1748 /* Write it down to memory. */
1749 write_memory_with_notification (addr
, buffer
, word_size
);
1750 /* Free the buffer. */
1751 do_cleanups (old_chain
);
1754 /* Implementation of the -data-write-memory-bytes command.
1757 DATA: string of bytes to write at that address
1758 COUNT: number of bytes to be filled (decimal integer). */
1761 mi_cmd_data_write_memory_bytes (char *command
, char **argv
, int argc
)
1767 size_t len_hex
, len_bytes
, len_units
, i
, steps
, remaining_units
;
1768 long int count_units
;
1769 struct cleanup
*back_to
;
1772 if (argc
!= 2 && argc
!= 3)
1773 error (_("Usage: ADDR DATA [COUNT]."));
1775 addr
= parse_and_eval_address (argv
[0]);
1777 len_hex
= strlen (cdata
);
1778 unit_size
= gdbarch_addressable_memory_unit_size (get_current_arch ());
1780 if (len_hex
% (unit_size
* 2) != 0)
1781 error (_("Hex-encoded '%s' must represent an integral number of "
1782 "addressable memory units."),
1785 len_bytes
= len_hex
/ 2;
1786 len_units
= len_bytes
/ unit_size
;
1789 count_units
= strtoul (argv
[2], NULL
, 10);
1791 count_units
= len_units
;
1793 databuf
= XNEWVEC (gdb_byte
, len_bytes
);
1794 back_to
= make_cleanup (xfree
, databuf
);
1796 for (i
= 0; i
< len_bytes
; ++i
)
1799 if (sscanf (cdata
+ i
* 2, "%02x", &x
) != 1)
1800 error (_("Invalid argument"));
1801 databuf
[i
] = (gdb_byte
) x
;
1804 if (len_units
< count_units
)
1806 /* Pattern is made of less units than count:
1807 repeat pattern to fill memory. */
1808 data
= (gdb_byte
*) xmalloc (count_units
* unit_size
);
1809 make_cleanup (xfree
, data
);
1811 /* Number of times the pattern is entirely repeated. */
1812 steps
= count_units
/ len_units
;
1813 /* Number of remaining addressable memory units. */
1814 remaining_units
= count_units
% len_units
;
1815 for (i
= 0; i
< steps
; i
++)
1816 memcpy (data
+ i
* len_bytes
, databuf
, len_bytes
);
1818 if (remaining_units
> 0)
1819 memcpy (data
+ steps
* len_bytes
, databuf
,
1820 remaining_units
* unit_size
);
1824 /* Pattern is longer than or equal to count:
1825 just copy count addressable memory units. */
1829 write_memory_with_notification (addr
, data
, count_units
);
1831 do_cleanups (back_to
);
1835 mi_cmd_enable_timings (char *command
, char **argv
, int argc
)
1841 if (strcmp (argv
[0], "yes") == 0)
1843 else if (strcmp (argv
[0], "no") == 0)
1854 error (_("-enable-timings: Usage: %s {yes|no}"), command
);
1858 mi_cmd_list_features (char *command
, char **argv
, int argc
)
1862 struct cleanup
*cleanup
= NULL
;
1863 struct ui_out
*uiout
= current_uiout
;
1865 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "features");
1866 ui_out_field_string (uiout
, NULL
, "frozen-varobjs");
1867 ui_out_field_string (uiout
, NULL
, "pending-breakpoints");
1868 ui_out_field_string (uiout
, NULL
, "thread-info");
1869 ui_out_field_string (uiout
, NULL
, "data-read-memory-bytes");
1870 ui_out_field_string (uiout
, NULL
, "breakpoint-notifications");
1871 ui_out_field_string (uiout
, NULL
, "ada-task-info");
1872 ui_out_field_string (uiout
, NULL
, "language-option");
1873 ui_out_field_string (uiout
, NULL
, "info-gdb-mi-command");
1874 ui_out_field_string (uiout
, NULL
, "undefined-command-error-code");
1875 ui_out_field_string (uiout
, NULL
, "exec-run-start-option");
1877 if (ext_lang_initialized_p (get_ext_lang_defn (EXT_LANG_PYTHON
)))
1878 ui_out_field_string (uiout
, NULL
, "python");
1880 do_cleanups (cleanup
);
1884 error (_("-list-features should be passed no arguments"));
1888 mi_cmd_list_target_features (char *command
, char **argv
, int argc
)
1892 struct cleanup
*cleanup
= NULL
;
1893 struct ui_out
*uiout
= current_uiout
;
1895 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "features");
1897 ui_out_field_string (uiout
, NULL
, "async");
1898 if (target_can_execute_reverse
)
1899 ui_out_field_string (uiout
, NULL
, "reverse");
1900 do_cleanups (cleanup
);
1904 error (_("-list-target-features should be passed no arguments"));
1908 mi_cmd_add_inferior (char *command
, char **argv
, int argc
)
1910 struct inferior
*inf
;
1913 error (_("-add-inferior should be passed no arguments"));
1915 inf
= add_inferior_with_spaces ();
1917 ui_out_field_fmt (current_uiout
, "inferior", "i%d", inf
->num
);
1920 /* Callback used to find the first inferior other than the current
1924 get_other_inferior (struct inferior
*inf
, void *arg
)
1926 if (inf
== current_inferior ())
1933 mi_cmd_remove_inferior (char *command
, char **argv
, int argc
)
1936 struct inferior
*inf
;
1939 error (_("-remove-inferior should be passed a single argument"));
1941 if (sscanf (argv
[0], "i%d", &id
) != 1)
1942 error (_("the thread group id is syntactically invalid"));
1944 inf
= find_inferior_id (id
);
1946 error (_("the specified thread group does not exist"));
1949 error (_("cannot remove an active inferior"));
1951 if (inf
== current_inferior ())
1953 struct thread_info
*tp
= 0;
1954 struct inferior
*new_inferior
1955 = iterate_over_inferiors (get_other_inferior
, NULL
);
1957 if (new_inferior
== NULL
)
1958 error (_("Cannot remove last inferior"));
1960 set_current_inferior (new_inferior
);
1961 if (new_inferior
->pid
!= 0)
1962 tp
= any_thread_of_process (new_inferior
->pid
);
1963 switch_to_thread (tp
? tp
->ptid
: null_ptid
);
1964 set_current_program_space (new_inferior
->pspace
);
1967 delete_inferior (inf
);
1972 /* Execute a command within a safe environment.
1973 Return <0 for error; >=0 for ok.
1975 args->action will tell mi_execute_command what action
1976 to perfrom after the given command has executed (display/suppress
1977 prompt, display error). */
1980 captured_mi_execute_command (struct ui_out
*uiout
, struct mi_parse
*context
)
1982 struct cleanup
*cleanup
;
1985 current_command_ts
= context
->cmd_start
;
1987 current_token
= xstrdup (context
->token
);
1988 cleanup
= make_cleanup (free_current_contents
, ¤t_token
);
1990 running_result_record_printed
= 0;
1992 switch (context
->op
)
1995 /* A MI command was read from the input stream. */
1997 /* FIXME: gdb_???? */
1998 fprintf_unfiltered (raw_stdout
, " token=`%s' command=`%s' args=`%s'\n",
1999 context
->token
, context
->command
, context
->args
);
2001 mi_cmd_execute (context
);
2003 /* Print the result if there were no errors.
2005 Remember that on the way out of executing a command, you have
2006 to directly use the mi_interp's uiout, since the command
2007 could have reset the interpreter, in which case the current
2008 uiout will most likely crash in the mi_out_* routines. */
2009 if (!running_result_record_printed
)
2011 fputs_unfiltered (context
->token
, raw_stdout
);
2012 /* There's no particularly good reason why target-connect results
2013 in not ^done. Should kill ^connected for MI3. */
2014 fputs_unfiltered (strcmp (context
->command
, "target-select") == 0
2015 ? "^connected" : "^done", raw_stdout
);
2016 mi_out_put (uiout
, raw_stdout
);
2017 mi_out_rewind (uiout
);
2018 mi_print_timing_maybe ();
2019 fputs_unfiltered ("\n", raw_stdout
);
2022 /* The command does not want anything to be printed. In that
2023 case, the command probably should not have written anything
2024 to uiout, but in case it has written something, discard it. */
2025 mi_out_rewind (uiout
);
2032 /* A CLI command was read from the input stream. */
2033 /* This "feature" will be removed as soon as we have a
2034 complete set of mi commands. */
2035 /* Echo the command on the console. */
2036 fprintf_unfiltered (gdb_stdlog
, "%s\n", context
->command
);
2037 /* Call the "console" interpreter. */
2038 argv
[0] = "console";
2039 argv
[1] = context
->command
;
2040 mi_cmd_interpreter_exec ("-interpreter-exec", argv
, 2);
2042 /* If we changed interpreters, DON'T print out anything. */
2043 if (current_interp_named_p (INTERP_MI
)
2044 || current_interp_named_p (INTERP_MI1
)
2045 || current_interp_named_p (INTERP_MI2
)
2046 || current_interp_named_p (INTERP_MI3
))
2048 if (!running_result_record_printed
)
2050 fputs_unfiltered (context
->token
, raw_stdout
);
2051 fputs_unfiltered ("^done", raw_stdout
);
2052 mi_out_put (uiout
, raw_stdout
);
2053 mi_out_rewind (uiout
);
2054 mi_print_timing_maybe ();
2055 fputs_unfiltered ("\n", raw_stdout
);
2058 mi_out_rewind (uiout
);
2064 do_cleanups (cleanup
);
2067 /* Print a gdb exception to the MI output stream. */
2070 mi_print_exception (const char *token
, struct gdb_exception exception
)
2072 fputs_unfiltered (token
, raw_stdout
);
2073 fputs_unfiltered ("^error,msg=\"", raw_stdout
);
2074 if (exception
.message
== NULL
)
2075 fputs_unfiltered ("unknown error", raw_stdout
);
2077 fputstr_unfiltered (exception
.message
, '"', raw_stdout
);
2078 fputs_unfiltered ("\"", raw_stdout
);
2080 switch (exception
.error
)
2082 case UNDEFINED_COMMAND_ERROR
:
2083 fputs_unfiltered (",code=\"undefined-command\"", raw_stdout
);
2087 fputs_unfiltered ("\n", raw_stdout
);
2091 mi_execute_command (const char *cmd
, int from_tty
)
2094 struct mi_parse
*command
= NULL
;
2096 /* This is to handle EOF (^D). We just quit gdb. */
2097 /* FIXME: we should call some API function here. */
2099 quit_force (NULL
, from_tty
);
2101 target_log_command (cmd
);
2105 command
= mi_parse (cmd
, &token
);
2107 CATCH (exception
, RETURN_MASK_ALL
)
2109 mi_print_exception (token
, exception
);
2114 if (command
!= NULL
)
2116 ptid_t previous_ptid
= inferior_ptid
;
2118 command
->token
= token
;
2122 command
->cmd_start
= XNEW (struct mi_timestamp
);
2123 timestamp (command
->cmd_start
);
2128 captured_mi_execute_command (current_uiout
, command
);
2130 CATCH (result
, RETURN_MASK_ALL
)
2132 /* The command execution failed and error() was called
2134 mi_print_exception (command
->token
, result
);
2135 mi_out_rewind (current_uiout
);
2139 bpstat_do_actions ();
2141 if (/* The notifications are only output when the top-level
2142 interpreter (specified on the command line) is MI. */
2143 ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ()))
2144 /* Don't try report anything if there are no threads --
2145 the program is dead. */
2146 && thread_count () != 0
2147 /* -thread-select explicitly changes thread. If frontend uses that
2148 internally, we don't want to emit =thread-selected, since
2149 =thread-selected is supposed to indicate user's intentions. */
2150 && strcmp (command
->command
, "thread-select") != 0)
2152 struct mi_interp
*mi
2153 = (struct mi_interp
*) top_level_interpreter_data ();
2154 int report_change
= 0;
2156 if (command
->thread
== -1)
2158 report_change
= (!ptid_equal (previous_ptid
, null_ptid
)
2159 && !ptid_equal (inferior_ptid
, previous_ptid
)
2160 && !ptid_equal (inferior_ptid
, null_ptid
));
2162 else if (!ptid_equal (inferior_ptid
, null_ptid
))
2164 struct thread_info
*ti
= inferior_thread ();
2166 report_change
= (ti
->global_num
!= command
->thread
);
2171 struct thread_info
*ti
= inferior_thread ();
2172 struct cleanup
*old_chain
;
2174 old_chain
= make_cleanup_restore_target_terminal ();
2175 target_terminal_ours_for_output ();
2177 fprintf_unfiltered (mi
->event_channel
,
2178 "thread-selected,id=\"%d\"",
2180 gdb_flush (mi
->event_channel
);
2182 do_cleanups (old_chain
);
2186 mi_parse_free (command
);
2191 mi_cmd_execute (struct mi_parse
*parse
)
2193 struct cleanup
*cleanup
;
2195 cleanup
= prepare_execute_command ();
2197 if (parse
->all
&& parse
->thread_group
!= -1)
2198 error (_("Cannot specify --thread-group together with --all"));
2200 if (parse
->all
&& parse
->thread
!= -1)
2201 error (_("Cannot specify --thread together with --all"));
2203 if (parse
->thread_group
!= -1 && parse
->thread
!= -1)
2204 error (_("Cannot specify --thread together with --thread-group"));
2206 if (parse
->frame
!= -1 && parse
->thread
== -1)
2207 error (_("Cannot specify --frame without --thread"));
2209 if (parse
->thread_group
!= -1)
2211 struct inferior
*inf
= find_inferior_id (parse
->thread_group
);
2212 struct thread_info
*tp
= 0;
2215 error (_("Invalid thread group for the --thread-group option"));
2217 set_current_inferior (inf
);
2218 /* This behaviour means that if --thread-group option identifies
2219 an inferior with multiple threads, then a random one will be
2220 picked. This is not a problem -- frontend should always
2221 provide --thread if it wishes to operate on a specific
2224 tp
= any_live_thread_of_process (inf
->pid
);
2225 switch_to_thread (tp
? tp
->ptid
: null_ptid
);
2226 set_current_program_space (inf
->pspace
);
2229 if (parse
->thread
!= -1)
2231 struct thread_info
*tp
= find_thread_global_id (parse
->thread
);
2234 error (_("Invalid thread id: %d"), parse
->thread
);
2236 if (is_exited (tp
->ptid
))
2237 error (_("Thread id: %d has terminated"), parse
->thread
);
2239 switch_to_thread (tp
->ptid
);
2242 if (parse
->frame
!= -1)
2244 struct frame_info
*fid
;
2245 int frame
= parse
->frame
;
2247 fid
= find_relative_frame (get_current_frame (), &frame
);
2249 /* find_relative_frame was successful */
2252 error (_("Invalid frame id: %d"), frame
);
2255 if (parse
->language
!= language_unknown
)
2257 make_cleanup_restore_current_language ();
2258 set_language (parse
->language
);
2261 current_context
= parse
;
2263 if (parse
->cmd
->suppress_notification
!= NULL
)
2265 make_cleanup_restore_integer (parse
->cmd
->suppress_notification
);
2266 *parse
->cmd
->suppress_notification
= 1;
2269 if (parse
->cmd
->argv_func
!= NULL
)
2271 parse
->cmd
->argv_func (parse
->command
, parse
->argv
, parse
->argc
);
2273 else if (parse
->cmd
->cli
.cmd
!= 0)
2275 /* FIXME: DELETE THIS. */
2276 /* The operation is still implemented by a cli command. */
2277 /* Must be a synchronous one. */
2278 mi_execute_cli_command (parse
->cmd
->cli
.cmd
, parse
->cmd
->cli
.args_p
,
2283 /* FIXME: DELETE THIS. */
2284 struct ui_file
*stb
;
2286 stb
= mem_fileopen ();
2288 fputs_unfiltered ("Undefined mi command: ", stb
);
2289 fputstr_unfiltered (parse
->command
, '"', stb
);
2290 fputs_unfiltered (" (missing implementation)", stb
);
2292 make_cleanup_ui_file_delete (stb
);
2295 do_cleanups (cleanup
);
2298 /* FIXME: This is just a hack so we can get some extra commands going.
2299 We don't want to channel things through the CLI, but call libgdb directly.
2300 Use only for synchronous commands. */
2303 mi_execute_cli_command (const char *cmd
, int args_p
, const char *args
)
2307 struct cleanup
*old_cleanups
;
2311 run
= xstrprintf ("%s %s", cmd
, args
);
2313 run
= xstrdup (cmd
);
2315 /* FIXME: gdb_???? */
2316 fprintf_unfiltered (gdb_stdout
, "cli=%s run=%s\n",
2318 old_cleanups
= make_cleanup (xfree
, run
);
2319 execute_command (run
, 0 /* from_tty */ );
2320 do_cleanups (old_cleanups
);
2326 mi_execute_async_cli_command (char *cli_command
, char **argv
, int argc
)
2328 struct cleanup
*old_cleanups
;
2332 run
= xstrprintf ("%s %s&", cli_command
, argc
? *argv
: "");
2334 run
= xstrprintf ("%s %s", cli_command
, argc
? *argv
: "");
2335 old_cleanups
= make_cleanup (xfree
, run
);
2337 execute_command (run
, 0 /* from_tty */ );
2339 /* Do this before doing any printing. It would appear that some
2340 print code leaves garbage around in the buffer. */
2341 do_cleanups (old_cleanups
);
2345 mi_load_progress (const char *section_name
,
2346 unsigned long sent_so_far
,
2347 unsigned long total_section
,
2348 unsigned long total_sent
,
2349 unsigned long grand_total
)
2351 struct timeval time_now
, delta
, update_threshold
;
2352 static struct timeval last_update
;
2353 static char *previous_sect_name
= NULL
;
2355 struct ui_out
*saved_uiout
;
2356 struct ui_out
*uiout
;
2358 /* This function is called through deprecated_show_load_progress
2359 which means uiout may not be correct. Fix it for the duration
2360 of this function. */
2361 saved_uiout
= current_uiout
;
2363 if (current_interp_named_p (INTERP_MI
)
2364 || current_interp_named_p (INTERP_MI2
))
2365 current_uiout
= mi_out_new (2);
2366 else if (current_interp_named_p (INTERP_MI1
))
2367 current_uiout
= mi_out_new (1);
2368 else if (current_interp_named_p (INTERP_MI3
))
2369 current_uiout
= mi_out_new (3);
2373 uiout
= current_uiout
;
2375 update_threshold
.tv_sec
= 0;
2376 update_threshold
.tv_usec
= 500000;
2377 gettimeofday (&time_now
, NULL
);
2379 delta
.tv_usec
= time_now
.tv_usec
- last_update
.tv_usec
;
2380 delta
.tv_sec
= time_now
.tv_sec
- last_update
.tv_sec
;
2382 if (delta
.tv_usec
< 0)
2385 delta
.tv_usec
+= 1000000L;
2388 new_section
= (previous_sect_name
?
2389 strcmp (previous_sect_name
, section_name
) : 1);
2392 struct cleanup
*cleanup_tuple
;
2394 xfree (previous_sect_name
);
2395 previous_sect_name
= xstrdup (section_name
);
2398 fputs_unfiltered (current_token
, raw_stdout
);
2399 fputs_unfiltered ("+download", raw_stdout
);
2400 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2401 ui_out_field_string (uiout
, "section", section_name
);
2402 ui_out_field_int (uiout
, "section-size", total_section
);
2403 ui_out_field_int (uiout
, "total-size", grand_total
);
2404 do_cleanups (cleanup_tuple
);
2405 mi_out_put (uiout
, raw_stdout
);
2406 fputs_unfiltered ("\n", raw_stdout
);
2407 gdb_flush (raw_stdout
);
2410 if (delta
.tv_sec
>= update_threshold
.tv_sec
&&
2411 delta
.tv_usec
>= update_threshold
.tv_usec
)
2413 struct cleanup
*cleanup_tuple
;
2415 last_update
.tv_sec
= time_now
.tv_sec
;
2416 last_update
.tv_usec
= time_now
.tv_usec
;
2418 fputs_unfiltered (current_token
, raw_stdout
);
2419 fputs_unfiltered ("+download", raw_stdout
);
2420 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2421 ui_out_field_string (uiout
, "section", section_name
);
2422 ui_out_field_int (uiout
, "section-sent", sent_so_far
);
2423 ui_out_field_int (uiout
, "section-size", total_section
);
2424 ui_out_field_int (uiout
, "total-sent", total_sent
);
2425 ui_out_field_int (uiout
, "total-size", grand_total
);
2426 do_cleanups (cleanup_tuple
);
2427 mi_out_put (uiout
, raw_stdout
);
2428 fputs_unfiltered ("\n", raw_stdout
);
2429 gdb_flush (raw_stdout
);
2433 current_uiout
= saved_uiout
;
2437 timestamp (struct mi_timestamp
*tv
)
2439 gettimeofday (&tv
->wallclock
, NULL
);
2440 #ifdef HAVE_GETRUSAGE
2441 getrusage (RUSAGE_SELF
, &rusage
);
2442 tv
->utime
.tv_sec
= rusage
.ru_utime
.tv_sec
;
2443 tv
->utime
.tv_usec
= rusage
.ru_utime
.tv_usec
;
2444 tv
->stime
.tv_sec
= rusage
.ru_stime
.tv_sec
;
2445 tv
->stime
.tv_usec
= rusage
.ru_stime
.tv_usec
;
2448 long usec
= get_run_time ();
2450 tv
->utime
.tv_sec
= usec
/1000000L;
2451 tv
->utime
.tv_usec
= usec
- 1000000L*tv
->utime
.tv_sec
;
2452 tv
->stime
.tv_sec
= 0;
2453 tv
->stime
.tv_usec
= 0;
2459 print_diff_now (struct mi_timestamp
*start
)
2461 struct mi_timestamp now
;
2464 print_diff (start
, &now
);
2468 mi_print_timing_maybe (void)
2470 /* If the command is -enable-timing then do_timings may be true
2471 whilst current_command_ts is not initialized. */
2472 if (do_timings
&& current_command_ts
)
2473 print_diff_now (current_command_ts
);
2477 timeval_diff (struct timeval start
, struct timeval end
)
2479 return ((end
.tv_sec
- start
.tv_sec
) * 1000000L)
2480 + (end
.tv_usec
- start
.tv_usec
);
2484 print_diff (struct mi_timestamp
*start
, struct mi_timestamp
*end
)
2488 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
2489 timeval_diff (start
->wallclock
, end
->wallclock
) / 1000000.0,
2490 timeval_diff (start
->utime
, end
->utime
) / 1000000.0,
2491 timeval_diff (start
->stime
, end
->stime
) / 1000000.0);
2495 mi_cmd_trace_define_variable (char *command
, char **argv
, int argc
)
2497 LONGEST initval
= 0;
2498 struct trace_state_variable
*tsv
;
2501 if (argc
!= 1 && argc
!= 2)
2502 error (_("Usage: -trace-define-variable VARIABLE [VALUE]"));
2506 error (_("Name of trace variable should start with '$'"));
2508 validate_trace_state_variable_name (name
);
2510 tsv
= find_trace_state_variable (name
);
2512 tsv
= create_trace_state_variable (name
);
2515 initval
= value_as_long (parse_and_eval (argv
[1]));
2517 tsv
->initial_value
= initval
;
2521 mi_cmd_trace_list_variables (char *command
, char **argv
, int argc
)
2524 error (_("-trace-list-variables: no arguments allowed"));
2526 tvariables_info_1 ();
2530 mi_cmd_trace_find (char *command
, char **argv
, int argc
)
2535 error (_("trace selection mode is required"));
2539 if (strcmp (mode
, "none") == 0)
2541 tfind_1 (tfind_number
, -1, 0, 0, 0);
2545 check_trace_running (current_trace_status ());
2547 if (strcmp (mode
, "frame-number") == 0)
2550 error (_("frame number is required"));
2551 tfind_1 (tfind_number
, atoi (argv
[1]), 0, 0, 0);
2553 else if (strcmp (mode
, "tracepoint-number") == 0)
2556 error (_("tracepoint number is required"));
2557 tfind_1 (tfind_tp
, atoi (argv
[1]), 0, 0, 0);
2559 else if (strcmp (mode
, "pc") == 0)
2562 error (_("PC is required"));
2563 tfind_1 (tfind_pc
, 0, parse_and_eval_address (argv
[1]), 0, 0);
2565 else if (strcmp (mode
, "pc-inside-range") == 0)
2568 error (_("Start and end PC are required"));
2569 tfind_1 (tfind_range
, 0, parse_and_eval_address (argv
[1]),
2570 parse_and_eval_address (argv
[2]), 0);
2572 else if (strcmp (mode
, "pc-outside-range") == 0)
2575 error (_("Start and end PC are required"));
2576 tfind_1 (tfind_outside
, 0, parse_and_eval_address (argv
[1]),
2577 parse_and_eval_address (argv
[2]), 0);
2579 else if (strcmp (mode
, "line") == 0)
2581 struct symtabs_and_lines sals
;
2582 struct symtab_and_line sal
;
2583 static CORE_ADDR start_pc
, end_pc
;
2584 struct cleanup
*back_to
;
2587 error (_("Line is required"));
2589 sals
= decode_line_with_current_source (argv
[1],
2590 DECODE_LINE_FUNFIRSTLINE
);
2591 back_to
= make_cleanup (xfree
, sals
.sals
);
2595 if (sal
.symtab
== 0)
2596 error (_("Could not find the specified line"));
2598 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2599 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, 0);
2601 error (_("Could not find the specified line"));
2603 do_cleanups (back_to
);
2606 error (_("Invalid mode '%s'"), mode
);
2608 if (has_stack_frames () || get_traceframe_number () >= 0)
2609 print_stack_frame (get_selected_frame (NULL
), 1, LOC_AND_ADDRESS
, 1);
2613 mi_cmd_trace_save (char *command
, char **argv
, int argc
)
2615 int target_saves
= 0;
2616 int generate_ctf
= 0;
2623 TARGET_SAVE_OPT
, CTF_OPT
2625 static const struct mi_opt opts
[] =
2627 {"r", TARGET_SAVE_OPT
, 0},
2628 {"ctf", CTF_OPT
, 0},
2634 int opt
= mi_getopt ("-trace-save", argc
, argv
, opts
,
2639 switch ((enum opt
) opt
)
2641 case TARGET_SAVE_OPT
:
2649 filename
= argv
[oind
];
2652 trace_save_ctf (filename
, target_saves
);
2654 trace_save_tfile (filename
, target_saves
);
2658 mi_cmd_trace_start (char *command
, char **argv
, int argc
)
2660 start_tracing (NULL
);
2664 mi_cmd_trace_status (char *command
, char **argv
, int argc
)
2666 trace_status_mi (0);
2670 mi_cmd_trace_stop (char *command
, char **argv
, int argc
)
2672 stop_tracing (NULL
);
2673 trace_status_mi (1);
2676 /* Implement the "-ada-task-info" command. */
2679 mi_cmd_ada_task_info (char *command
, char **argv
, int argc
)
2681 if (argc
!= 0 && argc
!= 1)
2682 error (_("Invalid MI command"));
2684 print_ada_task_info (current_uiout
, argv
[0], current_inferior ());
2687 /* Print EXPRESSION according to VALUES. */
2690 print_variable_or_computed (char *expression
, enum print_values values
)
2692 struct expression
*expr
;
2693 struct cleanup
*old_chain
;
2695 struct ui_file
*stb
;
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");