3 Copyright (C) 2000-2013 Free Software Foundation, Inc.
5 Contributed by Cygnus Solutions (a Red Hat company).
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "arch-utils.h"
27 #include "exceptions.h"
29 #include "gdbthread.h"
32 #include "mi-getopt.h"
33 #include "mi-console.h"
37 #include "event-loop.h"
38 #include "event-top.h"
39 #include "gdbcore.h" /* For write_memory(). */
45 #include "mi-common.h"
50 #include "splay-tree.h"
51 #include "tracepoint.h"
56 #include "python/python-internal.h"
62 #if defined HAVE_SYS_RESOURCE_H
63 #include <sys/resource.h>
77 struct ui_file
*raw_stdout
;
79 /* This is used to pass the current command timestamp down to
80 continuation routines. */
81 static struct mi_timestamp
*current_command_ts
;
83 static int do_timings
= 0;
86 /* Few commands would like to know if options like --thread-group were
87 explicitly specified. This variable keeps the current parsed
88 command including all option, and make it possible. */
89 static struct mi_parse
*current_context
;
91 int running_result_record_printed
= 1;
93 /* Flag indicating that the target has proceeded since the last
94 command was issued. */
97 extern void _initialize_mi_main (void);
98 static void mi_cmd_execute (struct mi_parse
*parse
);
100 static void mi_execute_cli_command (const char *cmd
, int args_p
,
102 static void mi_execute_async_cli_command (char *cli_command
,
103 char **argv
, int argc
);
104 static int register_changed_p (int regnum
, struct regcache
*,
106 static void output_register (struct frame_info
*, int regnum
, int format
,
107 int skip_unavailable
);
109 /* Command implementations. FIXME: Is this libgdb? No. This is the MI
110 layer that calls libgdb. Any operation used in the below should be
113 static void timestamp (struct mi_timestamp
*tv
);
115 static void print_diff_now (struct mi_timestamp
*start
);
116 static void print_diff (struct mi_timestamp
*start
, struct mi_timestamp
*end
);
119 mi_cmd_gdb_exit (char *command
, char **argv
, int argc
)
121 /* We have to print everything right here because we never return. */
123 fputs_unfiltered (current_token
, raw_stdout
);
124 fputs_unfiltered ("^exit\n", raw_stdout
);
125 mi_out_put (current_uiout
, raw_stdout
);
126 gdb_flush (raw_stdout
);
127 /* FIXME: The function called is not yet a formal libgdb function. */
128 quit_force (NULL
, FROM_TTY
);
132 mi_cmd_exec_next (char *command
, char **argv
, int argc
)
134 /* FIXME: Should call a libgdb function, not a cli wrapper. */
135 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
136 mi_execute_async_cli_command ("reverse-next", argv
+ 1, argc
- 1);
138 mi_execute_async_cli_command ("next", argv
, argc
);
142 mi_cmd_exec_next_instruction (char *command
, char **argv
, int argc
)
144 /* FIXME: Should call a libgdb function, not a cli wrapper. */
145 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
146 mi_execute_async_cli_command ("reverse-nexti", argv
+ 1, argc
- 1);
148 mi_execute_async_cli_command ("nexti", argv
, argc
);
152 mi_cmd_exec_step (char *command
, char **argv
, int argc
)
154 /* FIXME: Should call a libgdb function, not a cli wrapper. */
155 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
156 mi_execute_async_cli_command ("reverse-step", argv
+ 1, argc
- 1);
158 mi_execute_async_cli_command ("step", argv
, argc
);
162 mi_cmd_exec_step_instruction (char *command
, char **argv
, int argc
)
164 /* FIXME: Should call a libgdb function, not a cli wrapper. */
165 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
166 mi_execute_async_cli_command ("reverse-stepi", argv
+ 1, argc
- 1);
168 mi_execute_async_cli_command ("stepi", argv
, argc
);
172 mi_cmd_exec_finish (char *command
, char **argv
, int argc
)
174 /* FIXME: Should call a libgdb function, not a cli wrapper. */
175 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
176 mi_execute_async_cli_command ("reverse-finish", argv
+ 1, argc
- 1);
178 mi_execute_async_cli_command ("finish", argv
, argc
);
182 mi_cmd_exec_return (char *command
, char **argv
, int argc
)
184 /* This command doesn't really execute the target, it just pops the
185 specified number of frames. */
187 /* Call return_command with from_tty argument equal to 0 so as to
188 avoid being queried. */
189 return_command (*argv
, 0);
191 /* Call return_command with from_tty argument equal to 0 so as to
192 avoid being queried. */
193 return_command (NULL
, 0);
195 /* Because we have called return_command with from_tty = 0, we need
196 to print the frame here. */
197 print_stack_frame (get_selected_frame (NULL
), 1, LOC_AND_ADDRESS
, 1);
201 mi_cmd_exec_jump (char *args
, char **argv
, int argc
)
203 /* FIXME: Should call a libgdb function, not a cli wrapper. */
204 mi_execute_async_cli_command ("jump", argv
, argc
);
208 proceed_thread (struct thread_info
*thread
, int pid
)
210 if (!is_stopped (thread
->ptid
))
213 if (pid
!= 0 && ptid_get_pid (thread
->ptid
) != pid
)
216 switch_to_thread (thread
->ptid
);
217 clear_proceed_status ();
218 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
, 0);
222 proceed_thread_callback (struct thread_info
*thread
, void *arg
)
224 int pid
= *(int *)arg
;
226 proceed_thread (thread
, pid
);
231 exec_continue (char **argv
, int argc
)
235 /* In non-stop mode, 'resume' always resumes a single thread.
236 Therefore, to resume all threads of the current inferior, or
237 all threads in all inferiors, we need to iterate over
240 See comment on infcmd.c:proceed_thread_callback for rationale. */
241 if (current_context
->all
|| current_context
->thread_group
!= -1)
244 struct cleanup
*back_to
= make_cleanup_restore_current_thread ();
246 if (!current_context
->all
)
249 = find_inferior_id (current_context
->thread_group
);
253 iterate_over_threads (proceed_thread_callback
, &pid
);
254 do_cleanups (back_to
);
263 struct cleanup
*back_to
= make_cleanup_restore_integer (&sched_multi
);
265 if (current_context
->all
)
272 /* In all-stop mode, -exec-continue traditionally resumed
273 either all threads, or one thread, depending on the
274 'scheduler-locking' variable. Let's continue to do the
278 do_cleanups (back_to
);
283 exec_direction_forward (void *notused
)
285 execution_direction
= EXEC_FORWARD
;
289 exec_reverse_continue (char **argv
, int argc
)
291 enum exec_direction_kind dir
= execution_direction
;
292 struct cleanup
*old_chain
;
294 if (dir
== EXEC_REVERSE
)
295 error (_("Already in reverse mode."));
297 if (!target_can_execute_reverse
)
298 error (_("Target %s does not support this command."), target_shortname
);
300 old_chain
= make_cleanup (exec_direction_forward
, NULL
);
301 execution_direction
= EXEC_REVERSE
;
302 exec_continue (argv
, argc
);
303 do_cleanups (old_chain
);
307 mi_cmd_exec_continue (char *command
, char **argv
, int argc
)
309 if (argc
> 0 && strcmp (argv
[0], "--reverse") == 0)
310 exec_reverse_continue (argv
+ 1, argc
- 1);
312 exec_continue (argv
, argc
);
316 interrupt_thread_callback (struct thread_info
*thread
, void *arg
)
318 int pid
= *(int *)arg
;
320 if (!is_running (thread
->ptid
))
323 if (ptid_get_pid (thread
->ptid
) != pid
)
326 target_stop (thread
->ptid
);
330 /* Interrupt the execution of the target. Note how we must play
331 around with the token variables, in order to display the current
332 token in the result of the interrupt command, and the previous
333 execution token when the target finally stops. See comments in
337 mi_cmd_exec_interrupt (char *command
, char **argv
, int argc
)
339 /* In all-stop mode, everything stops, so we don't need to try
340 anything specific. */
343 interrupt_target_1 (0);
347 if (current_context
->all
)
349 /* This will interrupt all threads in all inferiors. */
350 interrupt_target_1 (1);
352 else if (current_context
->thread_group
!= -1)
354 struct inferior
*inf
= find_inferior_id (current_context
->thread_group
);
356 iterate_over_threads (interrupt_thread_callback
, &inf
->pid
);
360 /* Interrupt just the current thread -- either explicitly
361 specified via --thread or whatever was current before
362 MI command was sent. */
363 interrupt_target_1 (0);
367 /* Callback for iterate_over_inferiors which starts the execution
368 of the given inferior.
370 ARG is a pointer to an integer whose value, if non-zero, indicates
371 that the program should be stopped when reaching the main subprogram
372 (similar to what the CLI "start" command does). */
375 run_one_inferior (struct inferior
*inf
, void *arg
)
377 int start_p
= *(int *) arg
;
378 const char *run_cmd
= start_p
? "start" : "run";
382 if (inf
->pid
!= ptid_get_pid (inferior_ptid
))
384 struct thread_info
*tp
;
386 tp
= any_thread_of_process (inf
->pid
);
388 error (_("Inferior has no threads."));
390 switch_to_thread (tp
->ptid
);
395 set_current_inferior (inf
);
396 switch_to_thread (null_ptid
);
397 set_current_program_space (inf
->pspace
);
399 mi_execute_cli_command (run_cmd
, target_can_async_p (),
400 target_can_async_p () ? "&" : NULL
);
405 mi_cmd_exec_run (char *command
, char **argv
, int argc
)
410 /* Parse the command options. */
415 static const struct mi_opt opts
[] =
417 {"-start", START_OPT
, 0},
426 int opt
= mi_getopt ("-exec-run", argc
, argv
, opts
, &oind
, &oarg
);
430 switch ((enum opt
) opt
)
438 /* This command does not accept any argument. Make sure the user
439 did not provide any. */
441 error (_("Invalid argument: %s"), argv
[oind
]);
443 if (current_context
->all
)
445 struct cleanup
*back_to
= save_current_space_and_thread ();
447 iterate_over_inferiors (run_one_inferior
, &start_p
);
448 do_cleanups (back_to
);
452 const char *run_cmd
= start_p
? "start" : "run";
454 mi_execute_cli_command (run_cmd
, target_can_async_p (),
455 target_can_async_p () ? "&" : NULL
);
461 find_thread_of_process (struct thread_info
*ti
, void *p
)
465 if (ptid_get_pid (ti
->ptid
) == pid
&& !is_exited (ti
->ptid
))
472 mi_cmd_target_detach (char *command
, char **argv
, int argc
)
474 if (argc
!= 0 && argc
!= 1)
475 error (_("Usage: -target-detach [pid | thread-group]"));
479 struct thread_info
*tp
;
483 /* First see if we are dealing with a thread-group id. */
486 struct inferior
*inf
;
487 int id
= strtoul (argv
[0] + 1, &end
, 0);
490 error (_("Invalid syntax of thread-group id '%s'"), argv
[0]);
492 inf
= find_inferior_id (id
);
494 error (_("Non-existent thread-group id '%d'"), id
);
500 /* We must be dealing with a pid. */
501 pid
= strtol (argv
[0], &end
, 10);
504 error (_("Invalid identifier '%s'"), argv
[0]);
507 /* Pick any thread in the desired process. Current
508 target_detach detaches from the parent of inferior_ptid. */
509 tp
= iterate_over_threads (find_thread_of_process
, &pid
);
511 error (_("Thread group is empty"));
513 switch_to_thread (tp
->ptid
);
516 detach_command (NULL
, 0);
520 mi_cmd_thread_select (char *command
, char **argv
, int argc
)
523 char *mi_error_message
;
526 error (_("-thread-select: USAGE: threadnum."));
528 rc
= gdb_thread_select (current_uiout
, argv
[0], &mi_error_message
);
530 if (rc
== GDB_RC_FAIL
)
532 make_cleanup (xfree
, mi_error_message
);
533 error ("%s", mi_error_message
);
538 mi_cmd_thread_list_ids (char *command
, char **argv
, int argc
)
541 char *mi_error_message
;
544 error (_("-thread-list-ids: No arguments required."));
546 rc
= gdb_list_thread_ids (current_uiout
, &mi_error_message
);
548 if (rc
== GDB_RC_FAIL
)
550 make_cleanup (xfree
, mi_error_message
);
551 error ("%s", mi_error_message
);
556 mi_cmd_thread_info (char *command
, char **argv
, int argc
)
558 if (argc
!= 0 && argc
!= 1)
559 error (_("Invalid MI command"));
561 print_thread_info (current_uiout
, argv
[0], -1);
564 struct collect_cores_data
572 collect_cores (struct thread_info
*ti
, void *xdata
)
574 struct collect_cores_data
*data
= xdata
;
576 if (ptid_get_pid (ti
->ptid
) == data
->pid
)
578 int core
= target_core_of_thread (ti
->ptid
);
581 VEC_safe_push (int, data
->cores
, core
);
588 unique (int *b
, int *e
)
598 struct print_one_inferior_data
601 VEC (int) *inferiors
;
605 print_one_inferior (struct inferior
*inferior
, void *xdata
)
607 struct print_one_inferior_data
*top_data
= xdata
;
608 struct ui_out
*uiout
= current_uiout
;
610 if (VEC_empty (int, top_data
->inferiors
)
611 || bsearch (&(inferior
->pid
), VEC_address (int, top_data
->inferiors
),
612 VEC_length (int, top_data
->inferiors
), sizeof (int),
613 compare_positive_ints
))
615 struct collect_cores_data data
;
616 struct cleanup
*back_to
617 = make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
619 ui_out_field_fmt (uiout
, "id", "i%d", inferior
->num
);
620 ui_out_field_string (uiout
, "type", "process");
621 if (inferior
->pid
!= 0)
622 ui_out_field_int (uiout
, "pid", inferior
->pid
);
624 if (inferior
->pspace
->pspace_exec_filename
!= NULL
)
626 ui_out_field_string (uiout
, "executable",
627 inferior
->pspace
->pspace_exec_filename
);
631 if (inferior
->pid
!= 0)
633 data
.pid
= inferior
->pid
;
634 iterate_over_threads (collect_cores
, &data
);
637 if (!VEC_empty (int, data
.cores
))
640 struct cleanup
*back_to_2
=
641 make_cleanup_ui_out_list_begin_end (uiout
, "cores");
643 qsort (VEC_address (int, data
.cores
),
644 VEC_length (int, data
.cores
), sizeof (int),
645 compare_positive_ints
);
647 b
= VEC_address (int, data
.cores
);
648 e
= b
+ VEC_length (int, data
.cores
);
652 ui_out_field_int (uiout
, NULL
, *b
);
654 do_cleanups (back_to_2
);
657 if (top_data
->recurse
)
658 print_thread_info (uiout
, NULL
, inferior
->pid
);
660 do_cleanups (back_to
);
666 /* Output a field named 'cores' with a list as the value. The
667 elements of the list are obtained by splitting 'cores' on
671 output_cores (struct ui_out
*uiout
, const char *field_name
, const char *xcores
)
673 struct cleanup
*back_to
= make_cleanup_ui_out_list_begin_end (uiout
,
675 char *cores
= xstrdup (xcores
);
678 make_cleanup (xfree
, cores
);
680 for (p
= strtok (p
, ","); p
; p
= strtok (NULL
, ","))
681 ui_out_field_string (uiout
, NULL
, p
);
683 do_cleanups (back_to
);
687 free_vector_of_ints (void *xvector
)
689 VEC (int) **vector
= xvector
;
691 VEC_free (int, *vector
);
695 do_nothing (splay_tree_key k
)
700 free_vector_of_osdata_items (splay_tree_value xvalue
)
702 VEC (osdata_item_s
) *value
= (VEC (osdata_item_s
) *) xvalue
;
704 /* We don't free the items itself, it will be done separately. */
705 VEC_free (osdata_item_s
, value
);
709 splay_tree_int_comparator (splay_tree_key xa
, splay_tree_key xb
)
718 free_splay_tree (void *xt
)
721 splay_tree_delete (t
);
725 list_available_thread_groups (VEC (int) *ids
, int recurse
)
728 struct osdata_item
*item
;
730 struct ui_out
*uiout
= current_uiout
;
731 struct cleanup
*cleanup
;
733 /* This keeps a map from integer (pid) to VEC (struct osdata_item *)*
734 The vector contains information about all threads for the given pid.
735 This is assigned an initial value to avoid "may be used uninitialized"
737 splay_tree tree
= NULL
;
739 /* get_osdata will throw if it cannot return data. */
740 data
= get_osdata ("processes");
741 cleanup
= make_cleanup_osdata_free (data
);
745 struct osdata
*threads
= get_osdata ("threads");
747 make_cleanup_osdata_free (threads
);
748 tree
= splay_tree_new (splay_tree_int_comparator
,
750 free_vector_of_osdata_items
);
751 make_cleanup (free_splay_tree
, tree
);
754 VEC_iterate (osdata_item_s
, threads
->items
,
758 const char *pid
= get_osdata_column (item
, "pid");
759 int pid_i
= strtoul (pid
, NULL
, 0);
760 VEC (osdata_item_s
) *vec
= 0;
762 splay_tree_node n
= splay_tree_lookup (tree
, pid_i
);
765 VEC_safe_push (osdata_item_s
, vec
, item
);
766 splay_tree_insert (tree
, pid_i
, (splay_tree_value
)vec
);
770 vec
= (VEC (osdata_item_s
) *) n
->value
;
771 VEC_safe_push (osdata_item_s
, vec
, item
);
772 n
->value
= (splay_tree_value
) vec
;
777 make_cleanup_ui_out_list_begin_end (uiout
, "groups");
780 VEC_iterate (osdata_item_s
, data
->items
,
784 struct cleanup
*back_to
;
786 const char *pid
= get_osdata_column (item
, "pid");
787 const char *cmd
= get_osdata_column (item
, "command");
788 const char *user
= get_osdata_column (item
, "user");
789 const char *cores
= get_osdata_column (item
, "cores");
791 int pid_i
= strtoul (pid
, NULL
, 0);
793 /* At present, the target will return all available processes
794 and if information about specific ones was required, we filter
795 undesired processes here. */
796 if (ids
&& bsearch (&pid_i
, VEC_address (int, ids
),
797 VEC_length (int, ids
),
798 sizeof (int), compare_positive_ints
) == NULL
)
802 back_to
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
804 ui_out_field_fmt (uiout
, "id", "%s", pid
);
805 ui_out_field_string (uiout
, "type", "process");
807 ui_out_field_string (uiout
, "description", cmd
);
809 ui_out_field_string (uiout
, "user", user
);
811 output_cores (uiout
, "cores", cores
);
815 splay_tree_node n
= splay_tree_lookup (tree
, pid_i
);
818 VEC (osdata_item_s
) *children
= (VEC (osdata_item_s
) *) n
->value
;
819 struct osdata_item
*child
;
822 make_cleanup_ui_out_list_begin_end (uiout
, "threads");
825 VEC_iterate (osdata_item_s
, children
, ix_child
, child
);
828 struct cleanup
*back_to_2
=
829 make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
830 const char *tid
= get_osdata_column (child
, "tid");
831 const char *tcore
= get_osdata_column (child
, "core");
833 ui_out_field_string (uiout
, "id", tid
);
835 ui_out_field_string (uiout
, "core", tcore
);
837 do_cleanups (back_to_2
);
842 do_cleanups (back_to
);
845 do_cleanups (cleanup
);
849 mi_cmd_list_thread_groups (char *command
, char **argv
, int argc
)
851 struct ui_out
*uiout
= current_uiout
;
852 struct cleanup
*back_to
;
859 AVAILABLE_OPT
, RECURSE_OPT
861 static const struct mi_opt opts
[] =
863 {"-available", AVAILABLE_OPT
, 0},
864 {"-recurse", RECURSE_OPT
, 1},
873 int opt
= mi_getopt ("-list-thread-groups", argc
, argv
, opts
,
878 switch ((enum opt
) opt
)
884 if (strcmp (oarg
, "0") == 0)
886 else if (strcmp (oarg
, "1") == 0)
889 error (_("only '0' and '1' are valid values "
890 "for the '--recurse' option"));
895 for (; oind
< argc
; ++oind
)
900 if (*(argv
[oind
]) != 'i')
901 error (_("invalid syntax of group id '%s'"), argv
[oind
]);
903 inf
= strtoul (argv
[oind
] + 1, &end
, 0);
906 error (_("invalid syntax of group id '%s'"), argv
[oind
]);
907 VEC_safe_push (int, ids
, inf
);
909 if (VEC_length (int, ids
) > 1)
910 qsort (VEC_address (int, ids
),
911 VEC_length (int, ids
),
912 sizeof (int), compare_positive_ints
);
914 back_to
= make_cleanup (free_vector_of_ints
, &ids
);
918 list_available_thread_groups (ids
, recurse
);
920 else if (VEC_length (int, ids
) == 1)
922 /* Local thread groups, single id. */
923 int id
= *VEC_address (int, ids
);
924 struct inferior
*inf
= find_inferior_id (id
);
927 error (_("Non-existent thread group id '%d'"), id
);
929 print_thread_info (uiout
, NULL
, inf
->pid
);
933 struct print_one_inferior_data data
;
935 data
.recurse
= recurse
;
936 data
.inferiors
= ids
;
938 /* Local thread groups. Either no explicit ids -- and we
939 print everything, or several explicit ids. In both cases,
940 we print more than one group, and have to use 'groups'
941 as the top-level element. */
942 make_cleanup_ui_out_list_begin_end (uiout
, "groups");
943 update_thread_list ();
944 iterate_over_inferiors (print_one_inferior
, &data
);
947 do_cleanups (back_to
);
951 mi_cmd_data_list_register_names (char *command
, char **argv
, int argc
)
953 struct gdbarch
*gdbarch
;
954 struct ui_out
*uiout
= current_uiout
;
957 struct cleanup
*cleanup
;
959 /* Note that the test for a valid register must include checking the
960 gdbarch_register_name because gdbarch_num_regs may be allocated
961 for the union of the register sets within a family of related
962 processors. In this case, some entries of gdbarch_register_name
963 will change depending upon the particular processor being
966 gdbarch
= get_current_arch ();
967 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
969 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "register-names");
971 if (argc
== 0) /* No args, just do all the regs. */
977 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
978 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
979 ui_out_field_string (uiout
, NULL
, "");
981 ui_out_field_string (uiout
, NULL
,
982 gdbarch_register_name (gdbarch
, regnum
));
986 /* Else, list of register #s, just do listed regs. */
987 for (i
= 0; i
< argc
; i
++)
989 regnum
= atoi (argv
[i
]);
990 if (regnum
< 0 || regnum
>= numregs
)
991 error (_("bad register number"));
993 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
994 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
995 ui_out_field_string (uiout
, NULL
, "");
997 ui_out_field_string (uiout
, NULL
,
998 gdbarch_register_name (gdbarch
, regnum
));
1000 do_cleanups (cleanup
);
1004 mi_cmd_data_list_changed_registers (char *command
, char **argv
, int argc
)
1006 static struct regcache
*this_regs
= NULL
;
1007 struct ui_out
*uiout
= current_uiout
;
1008 struct regcache
*prev_regs
;
1009 struct gdbarch
*gdbarch
;
1010 int regnum
, numregs
, changed
;
1012 struct cleanup
*cleanup
;
1014 /* The last time we visited this function, the current frame's
1015 register contents were saved in THIS_REGS. Move THIS_REGS over
1016 to PREV_REGS, and refresh THIS_REGS with the now-current register
1019 prev_regs
= this_regs
;
1020 this_regs
= frame_save_as_regcache (get_selected_frame (NULL
));
1021 cleanup
= make_cleanup_regcache_xfree (prev_regs
);
1023 /* Note that the test for a valid register must include checking the
1024 gdbarch_register_name because gdbarch_num_regs may be allocated
1025 for the union of the register sets within a family of related
1026 processors. In this case, some entries of gdbarch_register_name
1027 will change depending upon the particular processor being
1030 gdbarch
= get_regcache_arch (this_regs
);
1031 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1033 make_cleanup_ui_out_list_begin_end (uiout
, "changed-registers");
1037 /* No args, just do all the regs. */
1042 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1043 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1045 changed
= register_changed_p (regnum
, prev_regs
, this_regs
);
1047 error (_("-data-list-changed-registers: "
1048 "Unable to read register contents."));
1050 ui_out_field_int (uiout
, NULL
, regnum
);
1054 /* Else, list of register #s, just do listed regs. */
1055 for (i
= 0; i
< argc
; i
++)
1057 regnum
= atoi (argv
[i
]);
1061 && gdbarch_register_name (gdbarch
, regnum
) != NULL
1062 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
1064 changed
= register_changed_p (regnum
, prev_regs
, this_regs
);
1066 error (_("-data-list-changed-registers: "
1067 "Unable to read register contents."));
1069 ui_out_field_int (uiout
, NULL
, regnum
);
1072 error (_("bad register number"));
1074 do_cleanups (cleanup
);
1078 register_changed_p (int regnum
, struct regcache
*prev_regs
,
1079 struct regcache
*this_regs
)
1081 struct gdbarch
*gdbarch
= get_regcache_arch (this_regs
);
1082 gdb_byte prev_buffer
[MAX_REGISTER_SIZE
];
1083 gdb_byte this_buffer
[MAX_REGISTER_SIZE
];
1084 enum register_status prev_status
;
1085 enum register_status this_status
;
1087 /* First time through or after gdbarch change consider all registers
1089 if (!prev_regs
|| get_regcache_arch (prev_regs
) != gdbarch
)
1092 /* Get register contents and compare. */
1093 prev_status
= regcache_cooked_read (prev_regs
, regnum
, prev_buffer
);
1094 this_status
= regcache_cooked_read (this_regs
, regnum
, this_buffer
);
1096 if (this_status
!= prev_status
)
1098 else if (this_status
== REG_VALID
)
1099 return memcmp (prev_buffer
, this_buffer
,
1100 register_size (gdbarch
, regnum
)) != 0;
1105 /* Return a list of register number and value pairs. The valid
1106 arguments expected are: a letter indicating the format in which to
1107 display the registers contents. This can be one of: x
1108 (hexadecimal), d (decimal), N (natural), t (binary), o (octal), r
1109 (raw). After the format argument there can be a sequence of
1110 numbers, indicating which registers to fetch the content of. If
1111 the format is the only argument, a list of all the registers with
1112 their values is returned. */
1115 mi_cmd_data_list_register_values (char *command
, char **argv
, int argc
)
1117 struct ui_out
*uiout
= current_uiout
;
1118 struct frame_info
*frame
;
1119 struct gdbarch
*gdbarch
;
1120 int regnum
, numregs
, format
;
1122 struct cleanup
*list_cleanup
;
1123 int skip_unavailable
= 0;
1129 static const struct mi_opt opts
[] =
1131 {"-skip-unavailable", SKIP_UNAVAILABLE
, 0},
1135 /* Note that the test for a valid register must include checking the
1136 gdbarch_register_name because gdbarch_num_regs may be allocated
1137 for the union of the register sets within a family of related
1138 processors. In this case, some entries of gdbarch_register_name
1139 will change depending upon the particular processor being
1145 int opt
= mi_getopt ("-data-list-register-values", argc
, argv
,
1146 opts
, &oind
, &oarg
);
1150 switch ((enum opt
) opt
)
1152 case SKIP_UNAVAILABLE
:
1153 skip_unavailable
= 1;
1158 if (argc
- oind
< 1)
1159 error (_("-data-list-register-values: Usage: "
1160 "-data-list-register-values [--skip-unavailable] <format>"
1161 " [<regnum1>...<regnumN>]"));
1163 format
= (int) argv
[oind
][0];
1165 frame
= get_selected_frame (NULL
);
1166 gdbarch
= get_frame_arch (frame
);
1167 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1169 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "register-values");
1171 if (argc
- oind
== 1)
1173 /* No args, beside the format: do all the regs. */
1178 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1179 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1182 output_register (frame
, regnum
, format
, skip_unavailable
);
1186 /* Else, list of register #s, just do listed regs. */
1187 for (i
= 1 + oind
; i
< argc
; i
++)
1189 regnum
= atoi (argv
[i
]);
1193 && gdbarch_register_name (gdbarch
, regnum
) != NULL
1194 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
1195 output_register (frame
, regnum
, format
, skip_unavailable
);
1197 error (_("bad register number"));
1199 do_cleanups (list_cleanup
);
1202 /* Output one register REGNUM's contents in the desired FORMAT. If
1203 SKIP_UNAVAILABLE is true, skip the register if it is
1207 output_register (struct frame_info
*frame
, int regnum
, int format
,
1208 int skip_unavailable
)
1210 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1211 struct ui_out
*uiout
= current_uiout
;
1212 struct value
*val
= value_of_register (regnum
, frame
);
1213 struct cleanup
*tuple_cleanup
;
1214 struct value_print_options opts
;
1215 struct ui_file
*stb
;
1217 if (skip_unavailable
&& !value_entirely_available (val
))
1220 tuple_cleanup
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1221 ui_out_field_int (uiout
, "number", regnum
);
1229 stb
= mem_fileopen ();
1230 make_cleanup_ui_file_delete (stb
);
1232 get_formatted_print_options (&opts
, format
);
1234 val_print (value_type (val
),
1235 value_contents_for_printing (val
),
1236 value_embedded_offset (val
), 0,
1237 stb
, 0, val
, &opts
, current_language
);
1238 ui_out_field_stream (uiout
, "value", stb
);
1240 do_cleanups (tuple_cleanup
);
1243 /* Write given values into registers. The registers and values are
1244 given as pairs. The corresponding MI command is
1245 -data-write-register-values <format>
1246 [<regnum1> <value1>...<regnumN> <valueN>] */
1248 mi_cmd_data_write_register_values (char *command
, char **argv
, int argc
)
1250 struct regcache
*regcache
;
1251 struct gdbarch
*gdbarch
;
1254 /* Note that the test for a valid register must include checking the
1255 gdbarch_register_name because gdbarch_num_regs may be allocated
1256 for the union of the register sets within a family of related
1257 processors. In this case, some entries of gdbarch_register_name
1258 will change depending upon the particular processor being
1261 regcache
= get_current_regcache ();
1262 gdbarch
= get_regcache_arch (regcache
);
1263 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1266 error (_("-data-write-register-values: Usage: -data-write-register-"
1267 "values <format> [<regnum1> <value1>...<regnumN> <valueN>]"));
1269 if (!target_has_registers
)
1270 error (_("-data-write-register-values: No registers."));
1273 error (_("-data-write-register-values: No regs and values specified."));
1276 error (_("-data-write-register-values: "
1277 "Regs and vals are not in pairs."));
1279 for (i
= 1; i
< argc
; i
= i
+ 2)
1281 int regnum
= atoi (argv
[i
]);
1283 if (regnum
>= 0 && regnum
< numregs
1284 && gdbarch_register_name (gdbarch
, regnum
)
1285 && *gdbarch_register_name (gdbarch
, regnum
))
1289 /* Get the value as a number. */
1290 value
= parse_and_eval_address (argv
[i
+ 1]);
1292 /* Write it down. */
1293 regcache_cooked_write_signed (regcache
, regnum
, value
);
1296 error (_("bad register number"));
1300 /* Evaluate the value of the argument. The argument is an
1301 expression. If the expression contains spaces it needs to be
1302 included in double quotes. */
1305 mi_cmd_data_evaluate_expression (char *command
, char **argv
, int argc
)
1307 struct expression
*expr
;
1308 struct cleanup
*old_chain
;
1310 struct ui_file
*stb
;
1311 struct value_print_options opts
;
1312 struct ui_out
*uiout
= current_uiout
;
1314 stb
= mem_fileopen ();
1315 old_chain
= make_cleanup_ui_file_delete (stb
);
1318 error (_("-data-evaluate-expression: "
1319 "Usage: -data-evaluate-expression expression"));
1321 expr
= parse_expression (argv
[0]);
1323 make_cleanup (free_current_contents
, &expr
);
1325 val
= evaluate_expression (expr
);
1327 /* Print the result of the expression evaluation. */
1328 get_user_print_options (&opts
);
1330 common_val_print (val
, stb
, 0, &opts
, current_language
);
1332 ui_out_field_stream (uiout
, "value", stb
);
1334 do_cleanups (old_chain
);
1337 /* This is the -data-read-memory command.
1339 ADDR: start address of data to be dumped.
1340 WORD-FORMAT: a char indicating format for the ``word''. See
1342 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
1343 NR_ROW: Number of rows.
1344 NR_COL: The number of colums (words per row).
1345 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
1346 ASCHAR for unprintable characters.
1348 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
1349 displayes them. Returns:
1351 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
1354 The number of bytes read is SIZE*ROW*COL. */
1357 mi_cmd_data_read_memory (char *command
, char **argv
, int argc
)
1359 struct gdbarch
*gdbarch
= get_current_arch ();
1360 struct ui_out
*uiout
= current_uiout
;
1361 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
1363 long total_bytes
, nr_cols
, nr_rows
;
1365 struct type
*word_type
;
1378 static const struct mi_opt opts
[] =
1380 {"o", OFFSET_OPT
, 1},
1386 int opt
= mi_getopt ("-data-read-memory", argc
, argv
, opts
,
1391 switch ((enum opt
) opt
)
1394 offset
= atol (oarg
);
1401 if (argc
< 5 || argc
> 6)
1402 error (_("-data-read-memory: Usage: "
1403 "ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR]."));
1405 /* Extract all the arguments. */
1407 /* Start address of the memory dump. */
1408 addr
= parse_and_eval_address (argv
[0]) + offset
;
1409 /* The format character to use when displaying a memory word. See
1410 the ``x'' command. */
1411 word_format
= argv
[1][0];
1412 /* The size of the memory word. */
1413 word_size
= atol (argv
[2]);
1417 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1421 word_type
= builtin_type (gdbarch
)->builtin_int16
;
1425 word_type
= builtin_type (gdbarch
)->builtin_int32
;
1429 word_type
= builtin_type (gdbarch
)->builtin_int64
;
1433 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1436 /* The number of rows. */
1437 nr_rows
= atol (argv
[3]);
1439 error (_("-data-read-memory: invalid number of rows."));
1441 /* Number of bytes per row. */
1442 nr_cols
= atol (argv
[4]);
1444 error (_("-data-read-memory: invalid number of columns."));
1446 /* The un-printable character when printing ascii. */
1452 /* Create a buffer and read it in. */
1453 total_bytes
= word_size
* nr_rows
* nr_cols
;
1454 mbuf
= xcalloc (total_bytes
, 1);
1455 make_cleanup (xfree
, mbuf
);
1457 /* Dispatch memory reads to the topmost target, not the flattened
1459 nr_bytes
= target_read (current_target
.beneath
,
1460 TARGET_OBJECT_MEMORY
, NULL
, mbuf
,
1463 error (_("Unable to read memory."));
1465 /* Output the header information. */
1466 ui_out_field_core_addr (uiout
, "addr", gdbarch
, addr
);
1467 ui_out_field_int (uiout
, "nr-bytes", nr_bytes
);
1468 ui_out_field_int (uiout
, "total-bytes", total_bytes
);
1469 ui_out_field_core_addr (uiout
, "next-row",
1470 gdbarch
, addr
+ word_size
* nr_cols
);
1471 ui_out_field_core_addr (uiout
, "prev-row",
1472 gdbarch
, addr
- word_size
* nr_cols
);
1473 ui_out_field_core_addr (uiout
, "next-page", gdbarch
, addr
+ total_bytes
);
1474 ui_out_field_core_addr (uiout
, "prev-page", gdbarch
, addr
- total_bytes
);
1476 /* Build the result as a two dimentional table. */
1478 struct ui_file
*stream
;
1479 struct cleanup
*cleanup_stream
;
1483 stream
= mem_fileopen ();
1484 cleanup_stream
= make_cleanup_ui_file_delete (stream
);
1486 make_cleanup_ui_out_list_begin_end (uiout
, "memory");
1487 for (row
= 0, row_byte
= 0;
1489 row
++, row_byte
+= nr_cols
* word_size
)
1493 struct cleanup
*cleanup_tuple
;
1494 struct cleanup
*cleanup_list_data
;
1495 struct value_print_options opts
;
1497 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1498 ui_out_field_core_addr (uiout
, "addr", gdbarch
, addr
+ row_byte
);
1499 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr +
1501 cleanup_list_data
= make_cleanup_ui_out_list_begin_end (uiout
, "data");
1502 get_formatted_print_options (&opts
, word_format
);
1503 for (col
= 0, col_byte
= row_byte
;
1505 col
++, col_byte
+= word_size
)
1507 if (col_byte
+ word_size
> nr_bytes
)
1509 ui_out_field_string (uiout
, NULL
, "N/A");
1513 ui_file_rewind (stream
);
1514 print_scalar_formatted (mbuf
+ col_byte
, word_type
, &opts
,
1515 word_asize
, stream
);
1516 ui_out_field_stream (uiout
, NULL
, stream
);
1519 do_cleanups (cleanup_list_data
);
1524 ui_file_rewind (stream
);
1525 for (byte
= row_byte
;
1526 byte
< row_byte
+ word_size
* nr_cols
; byte
++)
1528 if (byte
>= nr_bytes
)
1529 fputc_unfiltered ('X', stream
);
1530 else if (mbuf
[byte
] < 32 || mbuf
[byte
] > 126)
1531 fputc_unfiltered (aschar
, stream
);
1533 fputc_unfiltered (mbuf
[byte
], stream
);
1535 ui_out_field_stream (uiout
, "ascii", stream
);
1537 do_cleanups (cleanup_tuple
);
1539 do_cleanups (cleanup_stream
);
1541 do_cleanups (cleanups
);
1545 mi_cmd_data_read_memory_bytes (char *command
, char **argv
, int argc
)
1547 struct gdbarch
*gdbarch
= get_current_arch ();
1548 struct ui_out
*uiout
= current_uiout
;
1549 struct cleanup
*cleanups
;
1552 memory_read_result_s
*read_result
;
1554 VEC(memory_read_result_s
) *result
;
1562 static const struct mi_opt opts
[] =
1564 {"o", OFFSET_OPT
, 1},
1570 int opt
= mi_getopt ("-data-read-memory-bytes", argc
, argv
, opts
,
1574 switch ((enum opt
) opt
)
1577 offset
= atol (oarg
);
1585 error (_("Usage: [ -o OFFSET ] ADDR LENGTH."));
1587 addr
= parse_and_eval_address (argv
[0]) + offset
;
1588 length
= atol (argv
[1]);
1590 result
= read_memory_robust (current_target
.beneath
, addr
, length
);
1592 cleanups
= make_cleanup (free_memory_read_result_vector
, result
);
1594 if (VEC_length (memory_read_result_s
, result
) == 0)
1595 error (_("Unable to read memory."));
1597 make_cleanup_ui_out_list_begin_end (uiout
, "memory");
1599 VEC_iterate (memory_read_result_s
, result
, ix
, read_result
);
1602 struct cleanup
*t
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1606 ui_out_field_core_addr (uiout
, "begin", gdbarch
, read_result
->begin
);
1607 ui_out_field_core_addr (uiout
, "offset", gdbarch
, read_result
->begin
1609 ui_out_field_core_addr (uiout
, "end", gdbarch
, read_result
->end
);
1611 data
= xmalloc ((read_result
->end
- read_result
->begin
) * 2 + 1);
1613 for (i
= 0, p
= data
;
1614 i
< (read_result
->end
- read_result
->begin
);
1617 sprintf (p
, "%02x", read_result
->data
[i
]);
1619 ui_out_field_string (uiout
, "contents", data
);
1623 do_cleanups (cleanups
);
1626 /* Implementation of the -data-write_memory command.
1628 COLUMN_OFFSET: optional argument. Must be preceded by '-o'. The
1629 offset from the beginning of the memory grid row where the cell to
1631 ADDR: start address of the row in the memory grid where the memory
1632 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
1633 the location to write to.
1634 FORMAT: a char indicating format for the ``word''. See
1636 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
1637 VALUE: value to be written into the memory address.
1639 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1644 mi_cmd_data_write_memory (char *command
, char **argv
, int argc
)
1646 struct gdbarch
*gdbarch
= get_current_arch ();
1647 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1650 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1651 enough when using a compiler other than GCC. */
1654 struct cleanup
*old_chain
;
1662 static const struct mi_opt opts
[] =
1664 {"o", OFFSET_OPT
, 1},
1670 int opt
= mi_getopt ("-data-write-memory", argc
, argv
, opts
,
1675 switch ((enum opt
) opt
)
1678 offset
= atol (oarg
);
1686 error (_("-data-write-memory: Usage: "
1687 "[-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE."));
1689 /* Extract all the arguments. */
1690 /* Start address of the memory dump. */
1691 addr
= parse_and_eval_address (argv
[0]);
1692 /* The size of the memory word. */
1693 word_size
= atol (argv
[2]);
1695 /* Calculate the real address of the write destination. */
1696 addr
+= (offset
* word_size
);
1698 /* Get the value as a number. */
1699 value
= parse_and_eval_address (argv
[3]);
1700 /* Get the value into an array. */
1701 buffer
= xmalloc (word_size
);
1702 old_chain
= make_cleanup (xfree
, buffer
);
1703 store_signed_integer (buffer
, word_size
, byte_order
, value
);
1704 /* Write it down to memory. */
1705 write_memory_with_notification (addr
, buffer
, word_size
);
1706 /* Free the buffer. */
1707 do_cleanups (old_chain
);
1710 /* Implementation of the -data-write-memory-bytes command.
1713 DATA: string of bytes to write at that address
1714 COUNT: number of bytes to be filled (decimal integer). */
1717 mi_cmd_data_write_memory_bytes (char *command
, char **argv
, int argc
)
1723 size_t len
, i
, steps
, remainder
;
1725 struct cleanup
*back_to
;
1727 if (argc
!= 2 && argc
!= 3)
1728 error (_("Usage: ADDR DATA [COUNT]."));
1730 addr
= parse_and_eval_address (argv
[0]);
1732 if (strlen (cdata
) % 2)
1733 error (_("Hex-encoded '%s' must have an even number of characters."),
1736 len
= strlen (cdata
)/2;
1738 count
= strtoul (argv
[2], NULL
, 10);
1742 databuf
= xmalloc (len
* sizeof (gdb_byte
));
1743 back_to
= make_cleanup (xfree
, databuf
);
1745 for (i
= 0; i
< len
; ++i
)
1748 if (sscanf (cdata
+ i
* 2, "%02x", &x
) != 1)
1749 error (_("Invalid argument"));
1750 databuf
[i
] = (gdb_byte
) x
;
1755 /* Pattern is made of less bytes than count:
1756 repeat pattern to fill memory. */
1757 data
= xmalloc (count
);
1758 make_cleanup (xfree
, data
);
1760 steps
= count
/ len
;
1761 remainder
= count
% len
;
1762 for (j
= 0; j
< steps
; j
++)
1763 memcpy (data
+ j
* len
, databuf
, len
);
1766 memcpy (data
+ steps
* len
, databuf
, remainder
);
1770 /* Pattern is longer than or equal to count:
1771 just copy len bytes. */
1775 write_memory_with_notification (addr
, data
, count
);
1777 do_cleanups (back_to
);
1781 mi_cmd_enable_timings (char *command
, char **argv
, int argc
)
1787 if (strcmp (argv
[0], "yes") == 0)
1789 else if (strcmp (argv
[0], "no") == 0)
1800 error (_("-enable-timings: Usage: %s {yes|no}"), command
);
1804 mi_cmd_list_features (char *command
, char **argv
, int argc
)
1808 struct cleanup
*cleanup
= NULL
;
1809 struct ui_out
*uiout
= current_uiout
;
1811 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "features");
1812 ui_out_field_string (uiout
, NULL
, "frozen-varobjs");
1813 ui_out_field_string (uiout
, NULL
, "pending-breakpoints");
1814 ui_out_field_string (uiout
, NULL
, "thread-info");
1815 ui_out_field_string (uiout
, NULL
, "data-read-memory-bytes");
1816 ui_out_field_string (uiout
, NULL
, "breakpoint-notifications");
1817 ui_out_field_string (uiout
, NULL
, "ada-task-info");
1818 ui_out_field_string (uiout
, NULL
, "language-option");
1819 ui_out_field_string (uiout
, NULL
, "info-gdb-mi-command");
1820 ui_out_field_string (uiout
, NULL
, "undefined-command-error-code");
1823 if (gdb_python_initialized
)
1824 ui_out_field_string (uiout
, NULL
, "python");
1827 do_cleanups (cleanup
);
1831 error (_("-list-features should be passed no arguments"));
1835 mi_cmd_list_target_features (char *command
, char **argv
, int argc
)
1839 struct cleanup
*cleanup
= NULL
;
1840 struct ui_out
*uiout
= current_uiout
;
1842 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "features");
1843 if (target_can_async_p ())
1844 ui_out_field_string (uiout
, NULL
, "async");
1845 if (target_can_execute_reverse
)
1846 ui_out_field_string (uiout
, NULL
, "reverse");
1848 do_cleanups (cleanup
);
1852 error (_("-list-target-features should be passed no arguments"));
1856 mi_cmd_add_inferior (char *command
, char **argv
, int argc
)
1858 struct inferior
*inf
;
1861 error (_("-add-inferior should be passed no arguments"));
1863 inf
= add_inferior_with_spaces ();
1865 ui_out_field_fmt (current_uiout
, "inferior", "i%d", inf
->num
);
1868 /* Callback used to find the first inferior other than the current
1872 get_other_inferior (struct inferior
*inf
, void *arg
)
1874 if (inf
== current_inferior ())
1881 mi_cmd_remove_inferior (char *command
, char **argv
, int argc
)
1884 struct inferior
*inf
;
1887 error (_("-remove-inferior should be passed a single argument"));
1889 if (sscanf (argv
[0], "i%d", &id
) != 1)
1890 error (_("the thread group id is syntactically invalid"));
1892 inf
= find_inferior_id (id
);
1894 error (_("the specified thread group does not exist"));
1897 error (_("cannot remove an active inferior"));
1899 if (inf
== current_inferior ())
1901 struct thread_info
*tp
= 0;
1902 struct inferior
*new_inferior
1903 = iterate_over_inferiors (get_other_inferior
, NULL
);
1905 if (new_inferior
== NULL
)
1906 error (_("Cannot remove last inferior"));
1908 set_current_inferior (new_inferior
);
1909 if (new_inferior
->pid
!= 0)
1910 tp
= any_thread_of_process (new_inferior
->pid
);
1911 switch_to_thread (tp
? tp
->ptid
: null_ptid
);
1912 set_current_program_space (new_inferior
->pspace
);
1915 delete_inferior_1 (inf
, 1 /* silent */);
1920 /* Execute a command within a safe environment.
1921 Return <0 for error; >=0 for ok.
1923 args->action will tell mi_execute_command what action
1924 to perfrom after the given command has executed (display/suppress
1925 prompt, display error). */
1928 captured_mi_execute_command (struct ui_out
*uiout
, struct mi_parse
*context
)
1930 struct cleanup
*cleanup
;
1933 current_command_ts
= context
->cmd_start
;
1935 current_token
= xstrdup (context
->token
);
1936 cleanup
= make_cleanup (free_current_contents
, ¤t_token
);
1938 running_result_record_printed
= 0;
1940 switch (context
->op
)
1943 /* A MI command was read from the input stream. */
1945 /* FIXME: gdb_???? */
1946 fprintf_unfiltered (raw_stdout
, " token=`%s' command=`%s' args=`%s'\n",
1947 context
->token
, context
->command
, context
->args
);
1949 mi_cmd_execute (context
);
1951 /* Print the result if there were no errors.
1953 Remember that on the way out of executing a command, you have
1954 to directly use the mi_interp's uiout, since the command
1955 could have reset the interpreter, in which case the current
1956 uiout will most likely crash in the mi_out_* routines. */
1957 if (!running_result_record_printed
)
1959 fputs_unfiltered (context
->token
, raw_stdout
);
1960 /* There's no particularly good reason why target-connect results
1961 in not ^done. Should kill ^connected for MI3. */
1962 fputs_unfiltered (strcmp (context
->command
, "target-select") == 0
1963 ? "^connected" : "^done", raw_stdout
);
1964 mi_out_put (uiout
, raw_stdout
);
1965 mi_out_rewind (uiout
);
1966 mi_print_timing_maybe ();
1967 fputs_unfiltered ("\n", raw_stdout
);
1970 /* The command does not want anything to be printed. In that
1971 case, the command probably should not have written anything
1972 to uiout, but in case it has written something, discard it. */
1973 mi_out_rewind (uiout
);
1980 /* A CLI command was read from the input stream. */
1981 /* This "feature" will be removed as soon as we have a
1982 complete set of mi commands. */
1983 /* Echo the command on the console. */
1984 fprintf_unfiltered (gdb_stdlog
, "%s\n", context
->command
);
1985 /* Call the "console" interpreter. */
1986 argv
[0] = "console";
1987 argv
[1] = context
->command
;
1988 mi_cmd_interpreter_exec ("-interpreter-exec", argv
, 2);
1990 /* If we changed interpreters, DON'T print out anything. */
1991 if (current_interp_named_p (INTERP_MI
)
1992 || current_interp_named_p (INTERP_MI1
)
1993 || current_interp_named_p (INTERP_MI2
)
1994 || current_interp_named_p (INTERP_MI3
))
1996 if (!running_result_record_printed
)
1998 fputs_unfiltered (context
->token
, raw_stdout
);
1999 fputs_unfiltered ("^done", raw_stdout
);
2000 mi_out_put (uiout
, raw_stdout
);
2001 mi_out_rewind (uiout
);
2002 mi_print_timing_maybe ();
2003 fputs_unfiltered ("\n", raw_stdout
);
2006 mi_out_rewind (uiout
);
2012 do_cleanups (cleanup
);
2015 /* Print a gdb exception to the MI output stream. */
2018 mi_print_exception (const char *token
, struct gdb_exception exception
)
2020 fputs_unfiltered (token
, raw_stdout
);
2021 fputs_unfiltered ("^error,msg=\"", raw_stdout
);
2022 if (exception
.message
== NULL
)
2023 fputs_unfiltered ("unknown error", raw_stdout
);
2025 fputstr_unfiltered (exception
.message
, '"', raw_stdout
);
2026 fputs_unfiltered ("\"", raw_stdout
);
2028 switch (exception
.error
)
2030 case UNDEFINED_COMMAND_ERROR
:
2031 fputs_unfiltered (",code=\"undefined-command\"", raw_stdout
);
2035 fputs_unfiltered ("\n", raw_stdout
);
2039 mi_execute_command (const char *cmd
, int from_tty
)
2042 struct mi_parse
*command
= NULL
;
2043 volatile struct gdb_exception exception
;
2045 /* This is to handle EOF (^D). We just quit gdb. */
2046 /* FIXME: we should call some API function here. */
2048 quit_force (NULL
, from_tty
);
2050 target_log_command (cmd
);
2052 TRY_CATCH (exception
, RETURN_MASK_ALL
)
2054 command
= mi_parse (cmd
, &token
);
2056 if (exception
.reason
< 0)
2058 mi_print_exception (token
, exception
);
2063 volatile struct gdb_exception result
;
2064 ptid_t previous_ptid
= inferior_ptid
;
2066 command
->token
= token
;
2070 command
->cmd_start
= (struct mi_timestamp
*)
2071 xmalloc (sizeof (struct mi_timestamp
));
2072 timestamp (command
->cmd_start
);
2075 TRY_CATCH (result
, RETURN_MASK_ALL
)
2077 captured_mi_execute_command (current_uiout
, command
);
2079 if (result
.reason
< 0)
2081 /* The command execution failed and error() was called
2083 mi_print_exception (command
->token
, result
);
2084 mi_out_rewind (current_uiout
);
2087 bpstat_do_actions ();
2089 if (/* The notifications are only output when the top-level
2090 interpreter (specified on the command line) is MI. */
2091 ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ()))
2092 /* Don't try report anything if there are no threads --
2093 the program is dead. */
2094 && thread_count () != 0
2095 /* -thread-select explicitly changes thread. If frontend uses that
2096 internally, we don't want to emit =thread-selected, since
2097 =thread-selected is supposed to indicate user's intentions. */
2098 && strcmp (command
->command
, "thread-select") != 0)
2100 struct mi_interp
*mi
= top_level_interpreter_data ();
2101 int report_change
= 0;
2103 if (command
->thread
== -1)
2105 report_change
= (!ptid_equal (previous_ptid
, null_ptid
)
2106 && !ptid_equal (inferior_ptid
, previous_ptid
)
2107 && !ptid_equal (inferior_ptid
, null_ptid
));
2109 else if (!ptid_equal (inferior_ptid
, null_ptid
))
2111 struct thread_info
*ti
= inferior_thread ();
2113 report_change
= (ti
->num
!= command
->thread
);
2118 struct thread_info
*ti
= inferior_thread ();
2120 target_terminal_ours ();
2121 fprintf_unfiltered (mi
->event_channel
,
2122 "thread-selected,id=\"%d\"",
2124 gdb_flush (mi
->event_channel
);
2128 mi_parse_free (command
);
2133 mi_cmd_execute (struct mi_parse
*parse
)
2135 struct cleanup
*cleanup
;
2136 enum language saved_language
;
2138 cleanup
= prepare_execute_command ();
2140 if (parse
->all
&& parse
->thread_group
!= -1)
2141 error (_("Cannot specify --thread-group together with --all"));
2143 if (parse
->all
&& parse
->thread
!= -1)
2144 error (_("Cannot specify --thread together with --all"));
2146 if (parse
->thread_group
!= -1 && parse
->thread
!= -1)
2147 error (_("Cannot specify --thread together with --thread-group"));
2149 if (parse
->frame
!= -1 && parse
->thread
== -1)
2150 error (_("Cannot specify --frame without --thread"));
2152 if (parse
->thread_group
!= -1)
2154 struct inferior
*inf
= find_inferior_id (parse
->thread_group
);
2155 struct thread_info
*tp
= 0;
2158 error (_("Invalid thread group for the --thread-group option"));
2160 set_current_inferior (inf
);
2161 /* This behaviour means that if --thread-group option identifies
2162 an inferior with multiple threads, then a random one will be
2163 picked. This is not a problem -- frontend should always
2164 provide --thread if it wishes to operate on a specific
2167 tp
= any_live_thread_of_process (inf
->pid
);
2168 switch_to_thread (tp
? tp
->ptid
: null_ptid
);
2169 set_current_program_space (inf
->pspace
);
2172 if (parse
->thread
!= -1)
2174 struct thread_info
*tp
= find_thread_id (parse
->thread
);
2177 error (_("Invalid thread id: %d"), parse
->thread
);
2179 if (is_exited (tp
->ptid
))
2180 error (_("Thread id: %d has terminated"), parse
->thread
);
2182 switch_to_thread (tp
->ptid
);
2185 if (parse
->frame
!= -1)
2187 struct frame_info
*fid
;
2188 int frame
= parse
->frame
;
2190 fid
= find_relative_frame (get_current_frame (), &frame
);
2192 /* find_relative_frame was successful */
2195 error (_("Invalid frame id: %d"), frame
);
2198 if (parse
->language
!= language_unknown
)
2200 make_cleanup_restore_current_language ();
2201 set_language (parse
->language
);
2204 current_context
= parse
;
2206 if (parse
->cmd
->suppress_notification
!= NULL
)
2208 make_cleanup_restore_integer (parse
->cmd
->suppress_notification
);
2209 *parse
->cmd
->suppress_notification
= 1;
2212 if (parse
->cmd
->argv_func
!= NULL
)
2214 parse
->cmd
->argv_func (parse
->command
, parse
->argv
, parse
->argc
);
2216 else if (parse
->cmd
->cli
.cmd
!= 0)
2218 /* FIXME: DELETE THIS. */
2219 /* The operation is still implemented by a cli command. */
2220 /* Must be a synchronous one. */
2221 mi_execute_cli_command (parse
->cmd
->cli
.cmd
, parse
->cmd
->cli
.args_p
,
2226 /* FIXME: DELETE THIS. */
2227 struct ui_file
*stb
;
2229 stb
= mem_fileopen ();
2231 fputs_unfiltered ("Undefined mi command: ", stb
);
2232 fputstr_unfiltered (parse
->command
, '"', stb
);
2233 fputs_unfiltered (" (missing implementation)", stb
);
2235 make_cleanup_ui_file_delete (stb
);
2238 do_cleanups (cleanup
);
2241 /* FIXME: This is just a hack so we can get some extra commands going.
2242 We don't want to channel things through the CLI, but call libgdb directly.
2243 Use only for synchronous commands. */
2246 mi_execute_cli_command (const char *cmd
, int args_p
, const char *args
)
2250 struct cleanup
*old_cleanups
;
2254 run
= xstrprintf ("%s %s", cmd
, args
);
2256 run
= xstrdup (cmd
);
2258 /* FIXME: gdb_???? */
2259 fprintf_unfiltered (gdb_stdout
, "cli=%s run=%s\n",
2261 old_cleanups
= make_cleanup (xfree
, run
);
2262 execute_command (run
, 0 /* from_tty */ );
2263 do_cleanups (old_cleanups
);
2269 mi_execute_async_cli_command (char *cli_command
, char **argv
, int argc
)
2271 struct cleanup
*old_cleanups
;
2274 if (target_can_async_p ())
2275 run
= xstrprintf ("%s %s&", cli_command
, argc
? *argv
: "");
2277 run
= xstrprintf ("%s %s", cli_command
, argc
? *argv
: "");
2278 old_cleanups
= make_cleanup (xfree
, run
);
2280 execute_command (run
, 0 /* from_tty */ );
2282 /* Do this before doing any printing. It would appear that some
2283 print code leaves garbage around in the buffer. */
2284 do_cleanups (old_cleanups
);
2288 mi_load_progress (const char *section_name
,
2289 unsigned long sent_so_far
,
2290 unsigned long total_section
,
2291 unsigned long total_sent
,
2292 unsigned long grand_total
)
2294 struct timeval time_now
, delta
, update_threshold
;
2295 static struct timeval last_update
;
2296 static char *previous_sect_name
= NULL
;
2298 struct ui_out
*saved_uiout
;
2299 struct ui_out
*uiout
;
2301 /* This function is called through deprecated_show_load_progress
2302 which means uiout may not be correct. Fix it for the duration
2303 of this function. */
2304 saved_uiout
= current_uiout
;
2306 if (current_interp_named_p (INTERP_MI
)
2307 || current_interp_named_p (INTERP_MI2
))
2308 current_uiout
= mi_out_new (2);
2309 else if (current_interp_named_p (INTERP_MI1
))
2310 current_uiout
= mi_out_new (1);
2311 else if (current_interp_named_p (INTERP_MI3
))
2312 current_uiout
= mi_out_new (3);
2316 uiout
= current_uiout
;
2318 update_threshold
.tv_sec
= 0;
2319 update_threshold
.tv_usec
= 500000;
2320 gettimeofday (&time_now
, NULL
);
2322 delta
.tv_usec
= time_now
.tv_usec
- last_update
.tv_usec
;
2323 delta
.tv_sec
= time_now
.tv_sec
- last_update
.tv_sec
;
2325 if (delta
.tv_usec
< 0)
2328 delta
.tv_usec
+= 1000000L;
2331 new_section
= (previous_sect_name
?
2332 strcmp (previous_sect_name
, section_name
) : 1);
2335 struct cleanup
*cleanup_tuple
;
2337 xfree (previous_sect_name
);
2338 previous_sect_name
= xstrdup (section_name
);
2341 fputs_unfiltered (current_token
, raw_stdout
);
2342 fputs_unfiltered ("+download", raw_stdout
);
2343 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2344 ui_out_field_string (uiout
, "section", section_name
);
2345 ui_out_field_int (uiout
, "section-size", total_section
);
2346 ui_out_field_int (uiout
, "total-size", grand_total
);
2347 do_cleanups (cleanup_tuple
);
2348 mi_out_put (uiout
, raw_stdout
);
2349 fputs_unfiltered ("\n", raw_stdout
);
2350 gdb_flush (raw_stdout
);
2353 if (delta
.tv_sec
>= update_threshold
.tv_sec
&&
2354 delta
.tv_usec
>= update_threshold
.tv_usec
)
2356 struct cleanup
*cleanup_tuple
;
2358 last_update
.tv_sec
= time_now
.tv_sec
;
2359 last_update
.tv_usec
= time_now
.tv_usec
;
2361 fputs_unfiltered (current_token
, raw_stdout
);
2362 fputs_unfiltered ("+download", raw_stdout
);
2363 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2364 ui_out_field_string (uiout
, "section", section_name
);
2365 ui_out_field_int (uiout
, "section-sent", sent_so_far
);
2366 ui_out_field_int (uiout
, "section-size", total_section
);
2367 ui_out_field_int (uiout
, "total-sent", total_sent
);
2368 ui_out_field_int (uiout
, "total-size", grand_total
);
2369 do_cleanups (cleanup_tuple
);
2370 mi_out_put (uiout
, raw_stdout
);
2371 fputs_unfiltered ("\n", raw_stdout
);
2372 gdb_flush (raw_stdout
);
2376 current_uiout
= saved_uiout
;
2380 timestamp (struct mi_timestamp
*tv
)
2382 gettimeofday (&tv
->wallclock
, NULL
);
2383 #ifdef HAVE_GETRUSAGE
2384 getrusage (RUSAGE_SELF
, &rusage
);
2385 tv
->utime
.tv_sec
= rusage
.ru_utime
.tv_sec
;
2386 tv
->utime
.tv_usec
= rusage
.ru_utime
.tv_usec
;
2387 tv
->stime
.tv_sec
= rusage
.ru_stime
.tv_sec
;
2388 tv
->stime
.tv_usec
= rusage
.ru_stime
.tv_usec
;
2391 long usec
= get_run_time ();
2393 tv
->utime
.tv_sec
= usec
/1000000L;
2394 tv
->utime
.tv_usec
= usec
- 1000000L*tv
->utime
.tv_sec
;
2395 tv
->stime
.tv_sec
= 0;
2396 tv
->stime
.tv_usec
= 0;
2402 print_diff_now (struct mi_timestamp
*start
)
2404 struct mi_timestamp now
;
2407 print_diff (start
, &now
);
2411 mi_print_timing_maybe (void)
2413 /* If the command is -enable-timing then do_timings may be true
2414 whilst current_command_ts is not initialized. */
2415 if (do_timings
&& current_command_ts
)
2416 print_diff_now (current_command_ts
);
2420 timeval_diff (struct timeval start
, struct timeval end
)
2422 return ((end
.tv_sec
- start
.tv_sec
) * 1000000L)
2423 + (end
.tv_usec
- start
.tv_usec
);
2427 print_diff (struct mi_timestamp
*start
, struct mi_timestamp
*end
)
2431 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
2432 timeval_diff (start
->wallclock
, end
->wallclock
) / 1000000.0,
2433 timeval_diff (start
->utime
, end
->utime
) / 1000000.0,
2434 timeval_diff (start
->stime
, end
->stime
) / 1000000.0);
2438 mi_cmd_trace_define_variable (char *command
, char **argv
, int argc
)
2440 struct expression
*expr
;
2441 LONGEST initval
= 0;
2442 struct trace_state_variable
*tsv
;
2445 if (argc
!= 1 && argc
!= 2)
2446 error (_("Usage: -trace-define-variable VARIABLE [VALUE]"));
2450 error (_("Name of trace variable should start with '$'"));
2452 validate_trace_state_variable_name (name
);
2454 tsv
= find_trace_state_variable (name
);
2456 tsv
= create_trace_state_variable (name
);
2459 initval
= value_as_long (parse_and_eval (argv
[1]));
2461 tsv
->initial_value
= initval
;
2465 mi_cmd_trace_list_variables (char *command
, char **argv
, int argc
)
2468 error (_("-trace-list-variables: no arguments allowed"));
2470 tvariables_info_1 ();
2474 mi_cmd_trace_find (char *command
, char **argv
, int argc
)
2479 error (_("trace selection mode is required"));
2483 if (strcmp (mode
, "none") == 0)
2485 tfind_1 (tfind_number
, -1, 0, 0, 0);
2489 if (current_trace_status ()->running
)
2490 error (_("May not look at trace frames while trace is running."));
2492 if (strcmp (mode
, "frame-number") == 0)
2495 error (_("frame number is required"));
2496 tfind_1 (tfind_number
, atoi (argv
[1]), 0, 0, 0);
2498 else if (strcmp (mode
, "tracepoint-number") == 0)
2501 error (_("tracepoint number is required"));
2502 tfind_1 (tfind_tp
, atoi (argv
[1]), 0, 0, 0);
2504 else if (strcmp (mode
, "pc") == 0)
2507 error (_("PC is required"));
2508 tfind_1 (tfind_pc
, 0, parse_and_eval_address (argv
[1]), 0, 0);
2510 else if (strcmp (mode
, "pc-inside-range") == 0)
2513 error (_("Start and end PC are required"));
2514 tfind_1 (tfind_range
, 0, parse_and_eval_address (argv
[1]),
2515 parse_and_eval_address (argv
[2]), 0);
2517 else if (strcmp (mode
, "pc-outside-range") == 0)
2520 error (_("Start and end PC are required"));
2521 tfind_1 (tfind_outside
, 0, parse_and_eval_address (argv
[1]),
2522 parse_and_eval_address (argv
[2]), 0);
2524 else if (strcmp (mode
, "line") == 0)
2526 struct symtabs_and_lines sals
;
2527 struct symtab_and_line sal
;
2528 static CORE_ADDR start_pc
, end_pc
;
2529 struct cleanup
*back_to
;
2532 error (_("Line is required"));
2534 sals
= decode_line_with_current_source (argv
[1],
2535 DECODE_LINE_FUNFIRSTLINE
);
2536 back_to
= make_cleanup (xfree
, sals
.sals
);
2540 if (sal
.symtab
== 0)
2541 error (_("Could not find the specified line"));
2543 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2544 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, 0);
2546 error (_("Could not find the specified line"));
2548 do_cleanups (back_to
);
2551 error (_("Invalid mode '%s'"), mode
);
2553 if (has_stack_frames () || get_traceframe_number () >= 0)
2554 print_stack_frame (get_selected_frame (NULL
), 1, LOC_AND_ADDRESS
, 1);
2558 mi_cmd_trace_save (char *command
, char **argv
, int argc
)
2560 int target_saves
= 0;
2561 int generate_ctf
= 0;
2568 TARGET_SAVE_OPT
, CTF_OPT
2570 static const struct mi_opt opts
[] =
2572 {"r", TARGET_SAVE_OPT
, 0},
2573 {"ctf", CTF_OPT
, 0},
2579 int opt
= mi_getopt ("-trace-save", argc
, argv
, opts
,
2584 switch ((enum opt
) opt
)
2586 case TARGET_SAVE_OPT
:
2594 filename
= argv
[oind
];
2597 trace_save_ctf (filename
, target_saves
);
2599 trace_save_tfile (filename
, target_saves
);
2603 mi_cmd_trace_start (char *command
, char **argv
, int argc
)
2605 start_tracing (NULL
);
2609 mi_cmd_trace_status (char *command
, char **argv
, int argc
)
2611 trace_status_mi (0);
2615 mi_cmd_trace_stop (char *command
, char **argv
, int argc
)
2617 stop_tracing (NULL
);
2618 trace_status_mi (1);
2621 /* Implement the "-ada-task-info" command. */
2624 mi_cmd_ada_task_info (char *command
, char **argv
, int argc
)
2626 if (argc
!= 0 && argc
!= 1)
2627 error (_("Invalid MI command"));
2629 print_ada_task_info (current_uiout
, argv
[0], current_inferior ());
2632 /* Print EXPRESSION according to VALUES. */
2635 print_variable_or_computed (char *expression
, enum print_values values
)
2637 struct expression
*expr
;
2638 struct cleanup
*old_chain
;
2640 struct ui_file
*stb
;
2641 struct value_print_options opts
;
2643 struct ui_out
*uiout
= current_uiout
;
2645 stb
= mem_fileopen ();
2646 old_chain
= make_cleanup_ui_file_delete (stb
);
2648 expr
= parse_expression (expression
);
2650 make_cleanup (free_current_contents
, &expr
);
2652 if (values
== PRINT_SIMPLE_VALUES
)
2653 val
= evaluate_type (expr
);
2655 val
= evaluate_expression (expr
);
2657 if (values
!= PRINT_NO_VALUES
)
2658 make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2659 ui_out_field_string (uiout
, "name", expression
);
2663 case PRINT_SIMPLE_VALUES
:
2664 type
= check_typedef (value_type (val
));
2665 type_print (value_type (val
), "", stb
, -1);
2666 ui_out_field_stream (uiout
, "type", stb
);
2667 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
2668 && TYPE_CODE (type
) != TYPE_CODE_STRUCT
2669 && TYPE_CODE (type
) != TYPE_CODE_UNION
)
2671 struct value_print_options opts
;
2673 get_no_prettyformat_print_options (&opts
);
2675 common_val_print (val
, stb
, 0, &opts
, current_language
);
2676 ui_out_field_stream (uiout
, "value", stb
);
2679 case PRINT_ALL_VALUES
:
2681 struct value_print_options opts
;
2683 get_no_prettyformat_print_options (&opts
);
2685 common_val_print (val
, stb
, 0, &opts
, current_language
);
2686 ui_out_field_stream (uiout
, "value", stb
);
2691 do_cleanups (old_chain
);
2694 /* Implement the "-trace-frame-collected" command. */
2697 mi_cmd_trace_frame_collected (char *command
, char **argv
, int argc
)
2699 struct cleanup
*old_chain
;
2700 struct bp_location
*tloc
;
2702 struct collection_list
*clist
;
2703 struct collection_list tracepoint_list
, stepping_list
;
2704 struct traceframe_info
*tinfo
;
2706 int var_print_values
= PRINT_ALL_VALUES
;
2707 int comp_print_values
= PRINT_ALL_VALUES
;
2708 int registers_format
= 'x';
2709 int memory_contents
= 0;
2710 struct ui_out
*uiout
= current_uiout
;
2718 static const struct mi_opt opts
[] =
2720 {"-var-print-values", VAR_PRINT_VALUES
, 1},
2721 {"-comp-print-values", COMP_PRINT_VALUES
, 1},
2722 {"-registers-format", REGISTERS_FORMAT
, 1},
2723 {"-memory-contents", MEMORY_CONTENTS
, 0},
2730 int opt
= mi_getopt ("-trace-frame-collected", argc
, argv
, opts
,
2734 switch ((enum opt
) opt
)
2736 case VAR_PRINT_VALUES
:
2737 var_print_values
= mi_parse_print_values (oarg
);
2739 case COMP_PRINT_VALUES
:
2740 comp_print_values
= mi_parse_print_values (oarg
);
2742 case REGISTERS_FORMAT
:
2743 registers_format
= oarg
[0];
2744 case MEMORY_CONTENTS
:
2745 memory_contents
= 1;
2751 error (_("Usage: -trace-frame-collected "
2752 "[--var-print-values PRINT_VALUES] "
2753 "[--comp-print-values PRINT_VALUES] "
2754 "[--registers-format FORMAT]"
2755 "[--memory-contents]"));
2757 /* This throws an error is not inspecting a trace frame. */
2758 tloc
= get_traceframe_location (&stepping_frame
);
2760 /* This command only makes sense for the current frame, not the
2762 old_chain
= make_cleanup_restore_current_thread ();
2763 select_frame (get_current_frame ());
2765 encode_actions_and_make_cleanup (tloc
, &tracepoint_list
,
2769 clist
= &stepping_list
;
2771 clist
= &tracepoint_list
;
2773 tinfo
= get_traceframe_info ();
2775 /* Explicitly wholly collected variables. */
2777 struct cleanup
*list_cleanup
;
2781 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
,
2782 "explicit-variables");
2783 for (i
= 0; VEC_iterate (char_ptr
, clist
->wholly_collected
, i
, p
); i
++)
2784 print_variable_or_computed (p
, var_print_values
);
2785 do_cleanups (list_cleanup
);
2788 /* Computed expressions. */
2790 struct cleanup
*list_cleanup
;
2795 = make_cleanup_ui_out_list_begin_end (uiout
,
2796 "computed-expressions");
2797 for (i
= 0; VEC_iterate (char_ptr
, clist
->computed
, i
, p
); i
++)
2798 print_variable_or_computed (p
, comp_print_values
);
2799 do_cleanups (list_cleanup
);
2802 /* Registers. Given pseudo-registers, and that some architectures
2803 (like MIPS) actually hide the raw registers, we don't go through
2804 the trace frame info, but instead consult the register cache for
2805 register availability. */
2807 struct cleanup
*list_cleanup
;
2808 struct frame_info
*frame
;
2809 struct gdbarch
*gdbarch
;
2813 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "registers");
2815 frame
= get_selected_frame (NULL
);
2816 gdbarch
= get_frame_arch (frame
);
2817 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
2819 for (regnum
= 0; regnum
< numregs
; regnum
++)
2821 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
2822 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
2825 output_register (frame
, regnum
, registers_format
, 1);
2828 do_cleanups (list_cleanup
);
2831 /* Trace state variables. */
2833 struct cleanup
*list_cleanup
;
2838 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "tvars");
2841 make_cleanup (free_current_contents
, &tsvname
);
2843 for (i
= 0; VEC_iterate (int, tinfo
->tvars
, i
, tvar
); i
++)
2845 struct cleanup
*cleanup_child
;
2846 struct trace_state_variable
*tsv
;
2848 tsv
= find_trace_state_variable_by_number (tvar
);
2850 cleanup_child
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2854 tsvname
= xrealloc (tsvname
, strlen (tsv
->name
) + 2);
2856 strcpy (tsvname
+ 1, tsv
->name
);
2857 ui_out_field_string (uiout
, "name", tsvname
);
2859 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
2861 ui_out_field_int (uiout
, "current", tsv
->value
);
2865 ui_out_field_skip (uiout
, "name");
2866 ui_out_field_skip (uiout
, "current");
2869 do_cleanups (cleanup_child
);
2872 do_cleanups (list_cleanup
);
2877 struct cleanup
*list_cleanup
;
2878 VEC(mem_range_s
) *available_memory
= NULL
;
2879 struct mem_range
*r
;
2882 traceframe_available_memory (&available_memory
, 0, ULONGEST_MAX
);
2883 make_cleanup (VEC_cleanup(mem_range_s
), &available_memory
);
2885 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "memory");
2887 for (i
= 0; VEC_iterate (mem_range_s
, available_memory
, i
, r
); i
++)
2889 struct cleanup
*cleanup_child
;
2891 struct gdbarch
*gdbarch
= target_gdbarch ();
2893 cleanup_child
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2895 ui_out_field_core_addr (uiout
, "address", gdbarch
, r
->start
);
2896 ui_out_field_int (uiout
, "length", r
->length
);
2898 data
= xmalloc (r
->length
);
2899 make_cleanup (xfree
, data
);
2901 if (memory_contents
)
2903 if (target_read_memory (r
->start
, data
, r
->length
) == 0)
2908 data_str
= xmalloc (r
->length
* 2 + 1);
2909 make_cleanup (xfree
, data_str
);
2911 for (m
= 0, p
= data_str
; m
< r
->length
; ++m
, p
+= 2)
2912 sprintf (p
, "%02x", data
[m
]);
2913 ui_out_field_string (uiout
, "contents", data_str
);
2916 ui_out_field_skip (uiout
, "contents");
2918 do_cleanups (cleanup_child
);
2921 do_cleanups (list_cleanup
);
2924 do_cleanups (old_chain
);