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"
26 #include "gdb_string.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
);
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 && PIDGET (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 (PIDGET (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);
368 run_one_inferior (struct inferior
*inf
, void *arg
)
372 if (inf
->pid
!= ptid_get_pid (inferior_ptid
))
374 struct thread_info
*tp
;
376 tp
= any_thread_of_process (inf
->pid
);
378 error (_("Inferior has no threads."));
380 switch_to_thread (tp
->ptid
);
385 set_current_inferior (inf
);
386 switch_to_thread (null_ptid
);
387 set_current_program_space (inf
->pspace
);
389 mi_execute_cli_command ("run", target_can_async_p (),
390 target_can_async_p () ? "&" : NULL
);
395 mi_cmd_exec_run (char *command
, char **argv
, int argc
)
397 if (current_context
->all
)
399 struct cleanup
*back_to
= save_current_space_and_thread ();
401 iterate_over_inferiors (run_one_inferior
, NULL
);
402 do_cleanups (back_to
);
406 mi_execute_cli_command ("run", target_can_async_p (),
407 target_can_async_p () ? "&" : NULL
);
413 find_thread_of_process (struct thread_info
*ti
, void *p
)
417 if (PIDGET (ti
->ptid
) == pid
&& !is_exited (ti
->ptid
))
424 mi_cmd_target_detach (char *command
, char **argv
, int argc
)
426 if (argc
!= 0 && argc
!= 1)
427 error (_("Usage: -target-detach [pid | thread-group]"));
431 struct thread_info
*tp
;
435 /* First see if we are dealing with a thread-group id. */
438 struct inferior
*inf
;
439 int id
= strtoul (argv
[0] + 1, &end
, 0);
442 error (_("Invalid syntax of thread-group id '%s'"), argv
[0]);
444 inf
= find_inferior_id (id
);
446 error (_("Non-existent thread-group id '%d'"), id
);
452 /* We must be dealing with a pid. */
453 pid
= strtol (argv
[0], &end
, 10);
456 error (_("Invalid identifier '%s'"), argv
[0]);
459 /* Pick any thread in the desired process. Current
460 target_detach detaches from the parent of inferior_ptid. */
461 tp
= iterate_over_threads (find_thread_of_process
, &pid
);
463 error (_("Thread group is empty"));
465 switch_to_thread (tp
->ptid
);
468 detach_command (NULL
, 0);
472 mi_cmd_thread_select (char *command
, char **argv
, int argc
)
475 char *mi_error_message
;
478 error (_("-thread-select: USAGE: threadnum."));
480 rc
= gdb_thread_select (current_uiout
, argv
[0], &mi_error_message
);
482 if (rc
== GDB_RC_FAIL
)
484 make_cleanup (xfree
, mi_error_message
);
485 error ("%s", mi_error_message
);
490 mi_cmd_thread_list_ids (char *command
, char **argv
, int argc
)
493 char *mi_error_message
;
496 error (_("-thread-list-ids: No arguments required."));
498 rc
= gdb_list_thread_ids (current_uiout
, &mi_error_message
);
500 if (rc
== GDB_RC_FAIL
)
502 make_cleanup (xfree
, mi_error_message
);
503 error ("%s", mi_error_message
);
508 mi_cmd_thread_info (char *command
, char **argv
, int argc
)
510 if (argc
!= 0 && argc
!= 1)
511 error (_("Invalid MI command"));
513 print_thread_info (current_uiout
, argv
[0], -1);
516 struct collect_cores_data
524 collect_cores (struct thread_info
*ti
, void *xdata
)
526 struct collect_cores_data
*data
= xdata
;
528 if (ptid_get_pid (ti
->ptid
) == data
->pid
)
530 int core
= target_core_of_thread (ti
->ptid
);
533 VEC_safe_push (int, data
->cores
, core
);
540 unique (int *b
, int *e
)
550 struct print_one_inferior_data
553 VEC (int) *inferiors
;
557 print_one_inferior (struct inferior
*inferior
, void *xdata
)
559 struct print_one_inferior_data
*top_data
= xdata
;
560 struct ui_out
*uiout
= current_uiout
;
562 if (VEC_empty (int, top_data
->inferiors
)
563 || bsearch (&(inferior
->pid
), VEC_address (int, top_data
->inferiors
),
564 VEC_length (int, top_data
->inferiors
), sizeof (int),
565 compare_positive_ints
))
567 struct collect_cores_data data
;
568 struct cleanup
*back_to
569 = make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
571 ui_out_field_fmt (uiout
, "id", "i%d", inferior
->num
);
572 ui_out_field_string (uiout
, "type", "process");
573 if (inferior
->pid
!= 0)
574 ui_out_field_int (uiout
, "pid", inferior
->pid
);
576 if (inferior
->pspace
->ebfd
)
578 ui_out_field_string (uiout
, "executable",
579 bfd_get_filename (inferior
->pspace
->ebfd
));
583 if (inferior
->pid
!= 0)
585 data
.pid
= inferior
->pid
;
586 iterate_over_threads (collect_cores
, &data
);
589 if (!VEC_empty (int, data
.cores
))
592 struct cleanup
*back_to_2
=
593 make_cleanup_ui_out_list_begin_end (uiout
, "cores");
595 qsort (VEC_address (int, data
.cores
),
596 VEC_length (int, data
.cores
), sizeof (int),
597 compare_positive_ints
);
599 b
= VEC_address (int, data
.cores
);
600 e
= b
+ VEC_length (int, data
.cores
);
604 ui_out_field_int (uiout
, NULL
, *b
);
606 do_cleanups (back_to_2
);
609 if (top_data
->recurse
)
610 print_thread_info (uiout
, NULL
, inferior
->pid
);
612 do_cleanups (back_to
);
618 /* Output a field named 'cores' with a list as the value. The
619 elements of the list are obtained by splitting 'cores' on
623 output_cores (struct ui_out
*uiout
, const char *field_name
, const char *xcores
)
625 struct cleanup
*back_to
= make_cleanup_ui_out_list_begin_end (uiout
,
627 char *cores
= xstrdup (xcores
);
630 make_cleanup (xfree
, cores
);
632 for (p
= strtok (p
, ","); p
; p
= strtok (NULL
, ","))
633 ui_out_field_string (uiout
, NULL
, p
);
635 do_cleanups (back_to
);
639 free_vector_of_ints (void *xvector
)
641 VEC (int) **vector
= xvector
;
643 VEC_free (int, *vector
);
647 do_nothing (splay_tree_key k
)
652 free_vector_of_osdata_items (splay_tree_value xvalue
)
654 VEC (osdata_item_s
) *value
= (VEC (osdata_item_s
) *) xvalue
;
656 /* We don't free the items itself, it will be done separately. */
657 VEC_free (osdata_item_s
, value
);
661 splay_tree_int_comparator (splay_tree_key xa
, splay_tree_key xb
)
670 free_splay_tree (void *xt
)
673 splay_tree_delete (t
);
677 list_available_thread_groups (VEC (int) *ids
, int recurse
)
680 struct osdata_item
*item
;
682 struct ui_out
*uiout
= current_uiout
;
683 struct cleanup
*cleanup
;
685 /* This keeps a map from integer (pid) to VEC (struct osdata_item *)*
686 The vector contains information about all threads for the given pid.
687 This is assigned an initial value to avoid "may be used uninitialized"
689 splay_tree tree
= NULL
;
691 /* get_osdata will throw if it cannot return data. */
692 data
= get_osdata ("processes");
693 cleanup
= make_cleanup_osdata_free (data
);
697 struct osdata
*threads
= get_osdata ("threads");
699 make_cleanup_osdata_free (threads
);
700 tree
= splay_tree_new (splay_tree_int_comparator
,
702 free_vector_of_osdata_items
);
703 make_cleanup (free_splay_tree
, tree
);
706 VEC_iterate (osdata_item_s
, threads
->items
,
710 const char *pid
= get_osdata_column (item
, "pid");
711 int pid_i
= strtoul (pid
, NULL
, 0);
712 VEC (osdata_item_s
) *vec
= 0;
714 splay_tree_node n
= splay_tree_lookup (tree
, pid_i
);
717 VEC_safe_push (osdata_item_s
, vec
, item
);
718 splay_tree_insert (tree
, pid_i
, (splay_tree_value
)vec
);
722 vec
= (VEC (osdata_item_s
) *) n
->value
;
723 VEC_safe_push (osdata_item_s
, vec
, item
);
724 n
->value
= (splay_tree_value
) vec
;
729 make_cleanup_ui_out_list_begin_end (uiout
, "groups");
732 VEC_iterate (osdata_item_s
, data
->items
,
736 struct cleanup
*back_to
;
738 const char *pid
= get_osdata_column (item
, "pid");
739 const char *cmd
= get_osdata_column (item
, "command");
740 const char *user
= get_osdata_column (item
, "user");
741 const char *cores
= get_osdata_column (item
, "cores");
743 int pid_i
= strtoul (pid
, NULL
, 0);
745 /* At present, the target will return all available processes
746 and if information about specific ones was required, we filter
747 undesired processes here. */
748 if (ids
&& bsearch (&pid_i
, VEC_address (int, ids
),
749 VEC_length (int, ids
),
750 sizeof (int), compare_positive_ints
) == NULL
)
754 back_to
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
756 ui_out_field_fmt (uiout
, "id", "%s", pid
);
757 ui_out_field_string (uiout
, "type", "process");
759 ui_out_field_string (uiout
, "description", cmd
);
761 ui_out_field_string (uiout
, "user", user
);
763 output_cores (uiout
, "cores", cores
);
767 splay_tree_node n
= splay_tree_lookup (tree
, pid_i
);
770 VEC (osdata_item_s
) *children
= (VEC (osdata_item_s
) *) n
->value
;
771 struct osdata_item
*child
;
774 make_cleanup_ui_out_list_begin_end (uiout
, "threads");
777 VEC_iterate (osdata_item_s
, children
, ix_child
, child
);
780 struct cleanup
*back_to_2
=
781 make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
782 const char *tid
= get_osdata_column (child
, "tid");
783 const char *tcore
= get_osdata_column (child
, "core");
785 ui_out_field_string (uiout
, "id", tid
);
787 ui_out_field_string (uiout
, "core", tcore
);
789 do_cleanups (back_to_2
);
794 do_cleanups (back_to
);
797 do_cleanups (cleanup
);
801 mi_cmd_list_thread_groups (char *command
, char **argv
, int argc
)
803 struct ui_out
*uiout
= current_uiout
;
804 struct cleanup
*back_to
;
811 AVAILABLE_OPT
, RECURSE_OPT
813 static const struct mi_opt opts
[] =
815 {"-available", AVAILABLE_OPT
, 0},
816 {"-recurse", RECURSE_OPT
, 1},
825 int opt
= mi_getopt ("-list-thread-groups", argc
, argv
, opts
,
830 switch ((enum opt
) opt
)
836 if (strcmp (oarg
, "0") == 0)
838 else if (strcmp (oarg
, "1") == 0)
841 error (_("only '0' and '1' are valid values "
842 "for the '--recurse' option"));
847 for (; oind
< argc
; ++oind
)
852 if (*(argv
[oind
]) != 'i')
853 error (_("invalid syntax of group id '%s'"), argv
[oind
]);
855 inf
= strtoul (argv
[oind
] + 1, &end
, 0);
858 error (_("invalid syntax of group id '%s'"), argv
[oind
]);
859 VEC_safe_push (int, ids
, inf
);
861 if (VEC_length (int, ids
) > 1)
862 qsort (VEC_address (int, ids
),
863 VEC_length (int, ids
),
864 sizeof (int), compare_positive_ints
);
866 back_to
= make_cleanup (free_vector_of_ints
, &ids
);
870 list_available_thread_groups (ids
, recurse
);
872 else if (VEC_length (int, ids
) == 1)
874 /* Local thread groups, single id. */
875 int id
= *VEC_address (int, ids
);
876 struct inferior
*inf
= find_inferior_id (id
);
879 error (_("Non-existent thread group id '%d'"), id
);
881 print_thread_info (uiout
, NULL
, inf
->pid
);
885 struct print_one_inferior_data data
;
887 data
.recurse
= recurse
;
888 data
.inferiors
= ids
;
890 /* Local thread groups. Either no explicit ids -- and we
891 print everything, or several explicit ids. In both cases,
892 we print more than one group, and have to use 'groups'
893 as the top-level element. */
894 make_cleanup_ui_out_list_begin_end (uiout
, "groups");
895 update_thread_list ();
896 iterate_over_inferiors (print_one_inferior
, &data
);
899 do_cleanups (back_to
);
903 mi_cmd_data_list_register_names (char *command
, char **argv
, int argc
)
905 struct gdbarch
*gdbarch
;
906 struct ui_out
*uiout
= current_uiout
;
909 struct cleanup
*cleanup
;
911 /* Note that the test for a valid register must include checking the
912 gdbarch_register_name because gdbarch_num_regs may be allocated
913 for the union of the register sets within a family of related
914 processors. In this case, some entries of gdbarch_register_name
915 will change depending upon the particular processor being
918 gdbarch
= get_current_arch ();
919 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
921 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "register-names");
923 if (argc
== 0) /* No args, just do all the regs. */
929 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
930 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
931 ui_out_field_string (uiout
, NULL
, "");
933 ui_out_field_string (uiout
, NULL
,
934 gdbarch_register_name (gdbarch
, regnum
));
938 /* Else, list of register #s, just do listed regs. */
939 for (i
= 0; i
< argc
; i
++)
941 regnum
= atoi (argv
[i
]);
942 if (regnum
< 0 || regnum
>= numregs
)
943 error (_("bad register number"));
945 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
946 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
947 ui_out_field_string (uiout
, NULL
, "");
949 ui_out_field_string (uiout
, NULL
,
950 gdbarch_register_name (gdbarch
, regnum
));
952 do_cleanups (cleanup
);
956 mi_cmd_data_list_changed_registers (char *command
, char **argv
, int argc
)
958 static struct regcache
*this_regs
= NULL
;
959 struct ui_out
*uiout
= current_uiout
;
960 struct regcache
*prev_regs
;
961 struct gdbarch
*gdbarch
;
962 int regnum
, numregs
, changed
;
964 struct cleanup
*cleanup
;
966 /* The last time we visited this function, the current frame's
967 register contents were saved in THIS_REGS. Move THIS_REGS over
968 to PREV_REGS, and refresh THIS_REGS with the now-current register
971 prev_regs
= this_regs
;
972 this_regs
= frame_save_as_regcache (get_selected_frame (NULL
));
973 cleanup
= make_cleanup_regcache_xfree (prev_regs
);
975 /* Note that the test for a valid register must include checking the
976 gdbarch_register_name because gdbarch_num_regs may be allocated
977 for the union of the register sets within a family of related
978 processors. In this case, some entries of gdbarch_register_name
979 will change depending upon the particular processor being
982 gdbarch
= get_regcache_arch (this_regs
);
983 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
985 make_cleanup_ui_out_list_begin_end (uiout
, "changed-registers");
989 /* No args, just do all the regs. */
994 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
995 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
997 changed
= register_changed_p (regnum
, prev_regs
, this_regs
);
999 error (_("-data-list-changed-registers: "
1000 "Unable to read register contents."));
1002 ui_out_field_int (uiout
, NULL
, regnum
);
1006 /* Else, list of register #s, just do listed regs. */
1007 for (i
= 0; i
< argc
; i
++)
1009 regnum
= atoi (argv
[i
]);
1013 && gdbarch_register_name (gdbarch
, regnum
) != NULL
1014 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
1016 changed
= register_changed_p (regnum
, prev_regs
, this_regs
);
1018 error (_("-data-list-changed-registers: "
1019 "Unable to read register contents."));
1021 ui_out_field_int (uiout
, NULL
, regnum
);
1024 error (_("bad register number"));
1026 do_cleanups (cleanup
);
1030 register_changed_p (int regnum
, struct regcache
*prev_regs
,
1031 struct regcache
*this_regs
)
1033 struct gdbarch
*gdbarch
= get_regcache_arch (this_regs
);
1034 gdb_byte prev_buffer
[MAX_REGISTER_SIZE
];
1035 gdb_byte this_buffer
[MAX_REGISTER_SIZE
];
1036 enum register_status prev_status
;
1037 enum register_status this_status
;
1039 /* First time through or after gdbarch change consider all registers
1041 if (!prev_regs
|| get_regcache_arch (prev_regs
) != gdbarch
)
1044 /* Get register contents and compare. */
1045 prev_status
= regcache_cooked_read (prev_regs
, regnum
, prev_buffer
);
1046 this_status
= regcache_cooked_read (this_regs
, regnum
, this_buffer
);
1048 if (this_status
!= prev_status
)
1050 else if (this_status
== REG_VALID
)
1051 return memcmp (prev_buffer
, this_buffer
,
1052 register_size (gdbarch
, regnum
)) != 0;
1057 /* Return a list of register number and value pairs. The valid
1058 arguments expected are: a letter indicating the format in which to
1059 display the registers contents. This can be one of: x
1060 (hexadecimal), d (decimal), N (natural), t (binary), o (octal), r
1061 (raw). After the format argument there can be a sequence of
1062 numbers, indicating which registers to fetch the content of. If
1063 the format is the only argument, a list of all the registers with
1064 their values is returned. */
1067 mi_cmd_data_list_register_values (char *command
, char **argv
, int argc
)
1069 struct ui_out
*uiout
= current_uiout
;
1070 struct frame_info
*frame
;
1071 struct gdbarch
*gdbarch
;
1072 int regnum
, numregs
, format
;
1074 struct cleanup
*list_cleanup
;
1075 int skip_unavailable
= 0;
1081 static const struct mi_opt opts
[] =
1083 {"-skip-unavailable", SKIP_UNAVAILABLE
, 0},
1087 /* Note that the test for a valid register must include checking the
1088 gdbarch_register_name because gdbarch_num_regs may be allocated
1089 for the union of the register sets within a family of related
1090 processors. In this case, some entries of gdbarch_register_name
1091 will change depending upon the particular processor being
1097 int opt
= mi_getopt ("-data-list-register-values", argc
, argv
,
1098 opts
, &oind
, &oarg
);
1102 switch ((enum opt
) opt
)
1104 case SKIP_UNAVAILABLE
:
1105 skip_unavailable
= 1;
1110 if (argc
- oind
< 1)
1111 error (_("-data-list-register-values: Usage: "
1112 "-data-list-register-values [--skip-unavailable] <format>"
1113 " [<regnum1>...<regnumN>]"));
1115 format
= (int) argv
[oind
][0];
1117 frame
= get_selected_frame (NULL
);
1118 gdbarch
= get_frame_arch (frame
);
1119 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1121 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "register-values");
1123 if (argc
- oind
== 1)
1125 /* No args, beside the format: do all the regs. */
1130 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1131 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1134 output_register (frame
, regnum
, format
, skip_unavailable
);
1138 /* Else, list of register #s, just do listed regs. */
1139 for (i
= 1 + oind
; i
< argc
; i
++)
1141 regnum
= atoi (argv
[i
]);
1145 && gdbarch_register_name (gdbarch
, regnum
) != NULL
1146 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
1147 output_register (frame
, regnum
, format
, skip_unavailable
);
1149 error (_("bad register number"));
1151 do_cleanups (list_cleanup
);
1154 /* Output one register REGNUM's contents in the desired FORMAT. If
1155 SKIP_UNAVAILABLE is true, skip the register if it is
1159 output_register (struct frame_info
*frame
, int regnum
, int format
,
1160 int skip_unavailable
)
1162 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
1163 struct ui_out
*uiout
= current_uiout
;
1164 struct value
*val
= get_frame_register_value (frame
, regnum
);
1165 struct cleanup
*tuple_cleanup
;
1167 if (skip_unavailable
&& !value_entirely_available (val
))
1170 tuple_cleanup
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1171 ui_out_field_int (uiout
, "number", regnum
);
1176 if (value_optimized_out (val
))
1177 error (_("Optimized out"));
1182 char *ptr
, buf
[1024];
1183 const gdb_byte
*valaddr
= value_contents_for_printing (val
);
1187 for (j
= 0; j
< register_size (gdbarch
, regnum
); j
++)
1189 int idx
= gdbarch_byte_order (gdbarch
) == BFD_ENDIAN_BIG
?
1190 j
: register_size (gdbarch
, regnum
) - 1 - j
;
1192 sprintf (ptr
, "%02x", (unsigned char) valaddr
[idx
]);
1195 ui_out_field_string (uiout
, "value", buf
);
1199 struct value_print_options opts
;
1200 struct ui_file
*stb
;
1201 struct cleanup
*old_chain
;
1203 stb
= mem_fileopen ();
1204 old_chain
= make_cleanup_ui_file_delete (stb
);
1206 get_formatted_print_options (&opts
, format
);
1208 val_print (value_type (val
),
1209 value_contents_for_printing (val
),
1210 value_embedded_offset (val
), 0,
1211 stb
, 0, val
, &opts
, current_language
);
1212 ui_out_field_stream (uiout
, "value", stb
);
1213 do_cleanups (old_chain
);
1216 do_cleanups (tuple_cleanup
);
1219 /* Write given values into registers. The registers and values are
1220 given as pairs. The corresponding MI command is
1221 -data-write-register-values <format>
1222 [<regnum1> <value1>...<regnumN> <valueN>] */
1224 mi_cmd_data_write_register_values (char *command
, char **argv
, int argc
)
1226 struct regcache
*regcache
;
1227 struct gdbarch
*gdbarch
;
1230 /* Note that the test for a valid register must include checking the
1231 gdbarch_register_name because gdbarch_num_regs may be allocated
1232 for the union of the register sets within a family of related
1233 processors. In this case, some entries of gdbarch_register_name
1234 will change depending upon the particular processor being
1237 regcache
= get_current_regcache ();
1238 gdbarch
= get_regcache_arch (regcache
);
1239 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1242 error (_("-data-write-register-values: Usage: -data-write-register-"
1243 "values <format> [<regnum1> <value1>...<regnumN> <valueN>]"));
1245 if (!target_has_registers
)
1246 error (_("-data-write-register-values: No registers."));
1249 error (_("-data-write-register-values: No regs and values specified."));
1252 error (_("-data-write-register-values: "
1253 "Regs and vals are not in pairs."));
1255 for (i
= 1; i
< argc
; i
= i
+ 2)
1257 int regnum
= atoi (argv
[i
]);
1259 if (regnum
>= 0 && regnum
< numregs
1260 && gdbarch_register_name (gdbarch
, regnum
)
1261 && *gdbarch_register_name (gdbarch
, regnum
))
1265 /* Get the value as a number. */
1266 value
= parse_and_eval_address (argv
[i
+ 1]);
1268 /* Write it down. */
1269 regcache_cooked_write_signed (regcache
, regnum
, value
);
1272 error (_("bad register number"));
1276 /* Evaluate the value of the argument. The argument is an
1277 expression. If the expression contains spaces it needs to be
1278 included in double quotes. */
1281 mi_cmd_data_evaluate_expression (char *command
, char **argv
, int argc
)
1283 struct expression
*expr
;
1284 struct cleanup
*old_chain
;
1286 struct ui_file
*stb
;
1287 struct value_print_options opts
;
1288 struct ui_out
*uiout
= current_uiout
;
1290 stb
= mem_fileopen ();
1291 old_chain
= make_cleanup_ui_file_delete (stb
);
1294 error (_("-data-evaluate-expression: "
1295 "Usage: -data-evaluate-expression expression"));
1297 expr
= parse_expression (argv
[0]);
1299 make_cleanup (free_current_contents
, &expr
);
1301 val
= evaluate_expression (expr
);
1303 /* Print the result of the expression evaluation. */
1304 get_user_print_options (&opts
);
1306 common_val_print (val
, stb
, 0, &opts
, current_language
);
1308 ui_out_field_stream (uiout
, "value", stb
);
1310 do_cleanups (old_chain
);
1313 /* This is the -data-read-memory command.
1315 ADDR: start address of data to be dumped.
1316 WORD-FORMAT: a char indicating format for the ``word''. See
1318 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
1319 NR_ROW: Number of rows.
1320 NR_COL: The number of colums (words per row).
1321 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
1322 ASCHAR for unprintable characters.
1324 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
1325 displayes them. Returns:
1327 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
1330 The number of bytes read is SIZE*ROW*COL. */
1333 mi_cmd_data_read_memory (char *command
, char **argv
, int argc
)
1335 struct gdbarch
*gdbarch
= get_current_arch ();
1336 struct ui_out
*uiout
= current_uiout
;
1337 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
1339 long total_bytes
, nr_cols
, nr_rows
;
1341 struct type
*word_type
;
1354 static const struct mi_opt opts
[] =
1356 {"o", OFFSET_OPT
, 1},
1362 int opt
= mi_getopt ("-data-read-memory", argc
, argv
, opts
,
1367 switch ((enum opt
) opt
)
1370 offset
= atol (oarg
);
1377 if (argc
< 5 || argc
> 6)
1378 error (_("-data-read-memory: Usage: "
1379 "ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR]."));
1381 /* Extract all the arguments. */
1383 /* Start address of the memory dump. */
1384 addr
= parse_and_eval_address (argv
[0]) + offset
;
1385 /* The format character to use when displaying a memory word. See
1386 the ``x'' command. */
1387 word_format
= argv
[1][0];
1388 /* The size of the memory word. */
1389 word_size
= atol (argv
[2]);
1393 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1397 word_type
= builtin_type (gdbarch
)->builtin_int16
;
1401 word_type
= builtin_type (gdbarch
)->builtin_int32
;
1405 word_type
= builtin_type (gdbarch
)->builtin_int64
;
1409 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1412 /* The number of rows. */
1413 nr_rows
= atol (argv
[3]);
1415 error (_("-data-read-memory: invalid number of rows."));
1417 /* Number of bytes per row. */
1418 nr_cols
= atol (argv
[4]);
1420 error (_("-data-read-memory: invalid number of columns."));
1422 /* The un-printable character when printing ascii. */
1428 /* Create a buffer and read it in. */
1429 total_bytes
= word_size
* nr_rows
* nr_cols
;
1430 mbuf
= xcalloc (total_bytes
, 1);
1431 make_cleanup (xfree
, mbuf
);
1433 /* Dispatch memory reads to the topmost target, not the flattened
1435 nr_bytes
= target_read (current_target
.beneath
,
1436 TARGET_OBJECT_MEMORY
, NULL
, mbuf
,
1439 error (_("Unable to read memory."));
1441 /* Output the header information. */
1442 ui_out_field_core_addr (uiout
, "addr", gdbarch
, addr
);
1443 ui_out_field_int (uiout
, "nr-bytes", nr_bytes
);
1444 ui_out_field_int (uiout
, "total-bytes", total_bytes
);
1445 ui_out_field_core_addr (uiout
, "next-row",
1446 gdbarch
, addr
+ word_size
* nr_cols
);
1447 ui_out_field_core_addr (uiout
, "prev-row",
1448 gdbarch
, addr
- word_size
* nr_cols
);
1449 ui_out_field_core_addr (uiout
, "next-page", gdbarch
, addr
+ total_bytes
);
1450 ui_out_field_core_addr (uiout
, "prev-page", gdbarch
, addr
- total_bytes
);
1452 /* Build the result as a two dimentional table. */
1454 struct ui_file
*stream
;
1455 struct cleanup
*cleanup_stream
;
1459 stream
= mem_fileopen ();
1460 cleanup_stream
= make_cleanup_ui_file_delete (stream
);
1462 make_cleanup_ui_out_list_begin_end (uiout
, "memory");
1463 for (row
= 0, row_byte
= 0;
1465 row
++, row_byte
+= nr_cols
* word_size
)
1469 struct cleanup
*cleanup_tuple
;
1470 struct cleanup
*cleanup_list_data
;
1471 struct value_print_options opts
;
1473 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1474 ui_out_field_core_addr (uiout
, "addr", gdbarch
, addr
+ row_byte
);
1475 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr +
1477 cleanup_list_data
= make_cleanup_ui_out_list_begin_end (uiout
, "data");
1478 get_formatted_print_options (&opts
, word_format
);
1479 for (col
= 0, col_byte
= row_byte
;
1481 col
++, col_byte
+= word_size
)
1483 if (col_byte
+ word_size
> nr_bytes
)
1485 ui_out_field_string (uiout
, NULL
, "N/A");
1489 ui_file_rewind (stream
);
1490 print_scalar_formatted (mbuf
+ col_byte
, word_type
, &opts
,
1491 word_asize
, stream
);
1492 ui_out_field_stream (uiout
, NULL
, stream
);
1495 do_cleanups (cleanup_list_data
);
1500 ui_file_rewind (stream
);
1501 for (byte
= row_byte
;
1502 byte
< row_byte
+ word_size
* nr_cols
; byte
++)
1504 if (byte
>= nr_bytes
)
1505 fputc_unfiltered ('X', stream
);
1506 else if (mbuf
[byte
] < 32 || mbuf
[byte
] > 126)
1507 fputc_unfiltered (aschar
, stream
);
1509 fputc_unfiltered (mbuf
[byte
], stream
);
1511 ui_out_field_stream (uiout
, "ascii", stream
);
1513 do_cleanups (cleanup_tuple
);
1515 do_cleanups (cleanup_stream
);
1517 do_cleanups (cleanups
);
1521 mi_cmd_data_read_memory_bytes (char *command
, char **argv
, int argc
)
1523 struct gdbarch
*gdbarch
= get_current_arch ();
1524 struct ui_out
*uiout
= current_uiout
;
1525 struct cleanup
*cleanups
;
1528 memory_read_result_s
*read_result
;
1530 VEC(memory_read_result_s
) *result
;
1538 static const struct mi_opt opts
[] =
1540 {"o", OFFSET_OPT
, 1},
1546 int opt
= mi_getopt ("-data-read-memory-bytes", argc
, argv
, opts
,
1550 switch ((enum opt
) opt
)
1553 offset
= atol (oarg
);
1561 error (_("Usage: [ -o OFFSET ] ADDR LENGTH."));
1563 addr
= parse_and_eval_address (argv
[0]) + offset
;
1564 length
= atol (argv
[1]);
1566 result
= read_memory_robust (current_target
.beneath
, addr
, length
);
1568 cleanups
= make_cleanup (free_memory_read_result_vector
, result
);
1570 if (VEC_length (memory_read_result_s
, result
) == 0)
1571 error (_("Unable to read memory."));
1573 make_cleanup_ui_out_list_begin_end (uiout
, "memory");
1575 VEC_iterate (memory_read_result_s
, result
, ix
, read_result
);
1578 struct cleanup
*t
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1582 ui_out_field_core_addr (uiout
, "begin", gdbarch
, read_result
->begin
);
1583 ui_out_field_core_addr (uiout
, "offset", gdbarch
, read_result
->begin
1585 ui_out_field_core_addr (uiout
, "end", gdbarch
, read_result
->end
);
1587 data
= xmalloc ((read_result
->end
- read_result
->begin
) * 2 + 1);
1589 for (i
= 0, p
= data
;
1590 i
< (read_result
->end
- read_result
->begin
);
1593 sprintf (p
, "%02x", read_result
->data
[i
]);
1595 ui_out_field_string (uiout
, "contents", data
);
1599 do_cleanups (cleanups
);
1602 /* Implementation of the -data-write_memory command.
1604 COLUMN_OFFSET: optional argument. Must be preceded by '-o'. The
1605 offset from the beginning of the memory grid row where the cell to
1607 ADDR: start address of the row in the memory grid where the memory
1608 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
1609 the location to write to.
1610 FORMAT: a char indicating format for the ``word''. See
1612 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
1613 VALUE: value to be written into the memory address.
1615 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1620 mi_cmd_data_write_memory (char *command
, char **argv
, int argc
)
1622 struct gdbarch
*gdbarch
= get_current_arch ();
1623 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1626 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1627 enough when using a compiler other than GCC. */
1630 struct cleanup
*old_chain
;
1638 static const struct mi_opt opts
[] =
1640 {"o", OFFSET_OPT
, 1},
1646 int opt
= mi_getopt ("-data-write-memory", argc
, argv
, opts
,
1651 switch ((enum opt
) opt
)
1654 offset
= atol (oarg
);
1662 error (_("-data-write-memory: Usage: "
1663 "[-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE."));
1665 /* Extract all the arguments. */
1666 /* Start address of the memory dump. */
1667 addr
= parse_and_eval_address (argv
[0]);
1668 /* The size of the memory word. */
1669 word_size
= atol (argv
[2]);
1671 /* Calculate the real address of the write destination. */
1672 addr
+= (offset
* word_size
);
1674 /* Get the value as a number. */
1675 value
= parse_and_eval_address (argv
[3]);
1676 /* Get the value into an array. */
1677 buffer
= xmalloc (word_size
);
1678 old_chain
= make_cleanup (xfree
, buffer
);
1679 store_signed_integer (buffer
, word_size
, byte_order
, value
);
1680 /* Write it down to memory. */
1681 write_memory_with_notification (addr
, buffer
, word_size
);
1682 /* Free the buffer. */
1683 do_cleanups (old_chain
);
1686 /* Implementation of the -data-write-memory-bytes command.
1689 DATA: string of bytes to write at that address
1690 COUNT: number of bytes to be filled (decimal integer). */
1693 mi_cmd_data_write_memory_bytes (char *command
, char **argv
, int argc
)
1699 size_t len
, i
, steps
, remainder
;
1701 struct cleanup
*back_to
;
1703 if (argc
!= 2 && argc
!= 3)
1704 error (_("Usage: ADDR DATA [COUNT]."));
1706 addr
= parse_and_eval_address (argv
[0]);
1708 if (strlen (cdata
) % 2)
1709 error (_("Hex-encoded '%s' must have an even number of characters."),
1712 len
= strlen (cdata
)/2;
1714 count
= strtoul (argv
[2], NULL
, 10);
1718 databuf
= xmalloc (len
* sizeof (gdb_byte
));
1719 back_to
= make_cleanup (xfree
, databuf
);
1721 for (i
= 0; i
< len
; ++i
)
1724 if (sscanf (cdata
+ i
* 2, "%02x", &x
) != 1)
1725 error (_("Invalid argument"));
1726 databuf
[i
] = (gdb_byte
) x
;
1731 /* Pattern is made of less bytes than count:
1732 repeat pattern to fill memory. */
1733 data
= xmalloc (count
);
1734 make_cleanup (xfree
, data
);
1736 steps
= count
/ len
;
1737 remainder
= count
% len
;
1738 for (j
= 0; j
< steps
; j
++)
1739 memcpy (data
+ j
* len
, databuf
, len
);
1742 memcpy (data
+ steps
* len
, databuf
, remainder
);
1746 /* Pattern is longer than or equal to count:
1747 just copy len bytes. */
1751 write_memory_with_notification (addr
, data
, count
);
1753 do_cleanups (back_to
);
1757 mi_cmd_enable_timings (char *command
, char **argv
, int argc
)
1763 if (strcmp (argv
[0], "yes") == 0)
1765 else if (strcmp (argv
[0], "no") == 0)
1776 error (_("-enable-timings: Usage: %s {yes|no}"), command
);
1780 mi_cmd_list_features (char *command
, char **argv
, int argc
)
1784 struct cleanup
*cleanup
= NULL
;
1785 struct ui_out
*uiout
= current_uiout
;
1787 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "features");
1788 ui_out_field_string (uiout
, NULL
, "frozen-varobjs");
1789 ui_out_field_string (uiout
, NULL
, "pending-breakpoints");
1790 ui_out_field_string (uiout
, NULL
, "thread-info");
1791 ui_out_field_string (uiout
, NULL
, "data-read-memory-bytes");
1792 ui_out_field_string (uiout
, NULL
, "breakpoint-notifications");
1793 ui_out_field_string (uiout
, NULL
, "ada-task-info");
1796 if (gdb_python_initialized
)
1797 ui_out_field_string (uiout
, NULL
, "python");
1800 do_cleanups (cleanup
);
1804 error (_("-list-features should be passed no arguments"));
1808 mi_cmd_list_target_features (char *command
, char **argv
, int argc
)
1812 struct cleanup
*cleanup
= NULL
;
1813 struct ui_out
*uiout
= current_uiout
;
1815 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "features");
1816 if (target_can_async_p ())
1817 ui_out_field_string (uiout
, NULL
, "async");
1818 if (target_can_execute_reverse
)
1819 ui_out_field_string (uiout
, NULL
, "reverse");
1821 do_cleanups (cleanup
);
1825 error (_("-list-target-features should be passed no arguments"));
1829 mi_cmd_add_inferior (char *command
, char **argv
, int argc
)
1831 struct inferior
*inf
;
1834 error (_("-add-inferior should be passed no arguments"));
1836 inf
= add_inferior_with_spaces ();
1838 ui_out_field_fmt (current_uiout
, "inferior", "i%d", inf
->num
);
1841 /* Callback used to find the first inferior other than the current
1845 get_other_inferior (struct inferior
*inf
, void *arg
)
1847 if (inf
== current_inferior ())
1854 mi_cmd_remove_inferior (char *command
, char **argv
, int argc
)
1857 struct inferior
*inf
;
1860 error (_("-remove-inferior should be passed a single argument"));
1862 if (sscanf (argv
[0], "i%d", &id
) != 1)
1863 error (_("the thread group id is syntactically invalid"));
1865 inf
= find_inferior_id (id
);
1867 error (_("the specified thread group does not exist"));
1870 error (_("cannot remove an active inferior"));
1872 if (inf
== current_inferior ())
1874 struct thread_info
*tp
= 0;
1875 struct inferior
*new_inferior
1876 = iterate_over_inferiors (get_other_inferior
, NULL
);
1878 if (new_inferior
== NULL
)
1879 error (_("Cannot remove last inferior"));
1881 set_current_inferior (new_inferior
);
1882 if (new_inferior
->pid
!= 0)
1883 tp
= any_thread_of_process (new_inferior
->pid
);
1884 switch_to_thread (tp
? tp
->ptid
: null_ptid
);
1885 set_current_program_space (new_inferior
->pspace
);
1888 delete_inferior_1 (inf
, 1 /* silent */);
1893 /* Execute a command within a safe environment.
1894 Return <0 for error; >=0 for ok.
1896 args->action will tell mi_execute_command what action
1897 to perfrom after the given command has executed (display/suppress
1898 prompt, display error). */
1901 captured_mi_execute_command (struct ui_out
*uiout
, struct mi_parse
*context
)
1903 struct cleanup
*cleanup
;
1906 current_command_ts
= context
->cmd_start
;
1908 current_token
= xstrdup (context
->token
);
1909 cleanup
= make_cleanup (free_current_contents
, ¤t_token
);
1911 running_result_record_printed
= 0;
1913 switch (context
->op
)
1916 /* A MI command was read from the input stream. */
1918 /* FIXME: gdb_???? */
1919 fprintf_unfiltered (raw_stdout
, " token=`%s' command=`%s' args=`%s'\n",
1920 context
->token
, context
->command
, context
->args
);
1922 mi_cmd_execute (context
);
1924 /* Print the result if there were no errors.
1926 Remember that on the way out of executing a command, you have
1927 to directly use the mi_interp's uiout, since the command
1928 could have reset the interpreter, in which case the current
1929 uiout will most likely crash in the mi_out_* routines. */
1930 if (!running_result_record_printed
)
1932 fputs_unfiltered (context
->token
, raw_stdout
);
1933 /* There's no particularly good reason why target-connect results
1934 in not ^done. Should kill ^connected for MI3. */
1935 fputs_unfiltered (strcmp (context
->command
, "target-select") == 0
1936 ? "^connected" : "^done", raw_stdout
);
1937 mi_out_put (uiout
, raw_stdout
);
1938 mi_out_rewind (uiout
);
1939 mi_print_timing_maybe ();
1940 fputs_unfiltered ("\n", raw_stdout
);
1943 /* The command does not want anything to be printed. In that
1944 case, the command probably should not have written anything
1945 to uiout, but in case it has written something, discard it. */
1946 mi_out_rewind (uiout
);
1953 /* A CLI command was read from the input stream. */
1954 /* This "feature" will be removed as soon as we have a
1955 complete set of mi commands. */
1956 /* Echo the command on the console. */
1957 fprintf_unfiltered (gdb_stdlog
, "%s\n", context
->command
);
1958 /* Call the "console" interpreter. */
1959 argv
[0] = "console";
1960 argv
[1] = context
->command
;
1961 mi_cmd_interpreter_exec ("-interpreter-exec", argv
, 2);
1963 /* If we changed interpreters, DON'T print out anything. */
1964 if (current_interp_named_p (INTERP_MI
)
1965 || current_interp_named_p (INTERP_MI1
)
1966 || current_interp_named_p (INTERP_MI2
)
1967 || current_interp_named_p (INTERP_MI3
))
1969 if (!running_result_record_printed
)
1971 fputs_unfiltered (context
->token
, raw_stdout
);
1972 fputs_unfiltered ("^done", raw_stdout
);
1973 mi_out_put (uiout
, raw_stdout
);
1974 mi_out_rewind (uiout
);
1975 mi_print_timing_maybe ();
1976 fputs_unfiltered ("\n", raw_stdout
);
1979 mi_out_rewind (uiout
);
1985 do_cleanups (cleanup
);
1988 /* Print a gdb exception to the MI output stream. */
1991 mi_print_exception (const char *token
, struct gdb_exception exception
)
1993 fputs_unfiltered (token
, raw_stdout
);
1994 fputs_unfiltered ("^error,msg=\"", raw_stdout
);
1995 if (exception
.message
== NULL
)
1996 fputs_unfiltered ("unknown error", raw_stdout
);
1998 fputstr_unfiltered (exception
.message
, '"', raw_stdout
);
1999 fputs_unfiltered ("\"\n", raw_stdout
);
2003 mi_execute_command (const char *cmd
, int from_tty
)
2006 struct mi_parse
*command
= NULL
;
2007 volatile struct gdb_exception exception
;
2009 /* This is to handle EOF (^D). We just quit gdb. */
2010 /* FIXME: we should call some API function here. */
2012 quit_force (NULL
, from_tty
);
2014 target_log_command (cmd
);
2016 TRY_CATCH (exception
, RETURN_MASK_ALL
)
2018 command
= mi_parse (cmd
, &token
);
2020 if (exception
.reason
< 0)
2022 mi_print_exception (token
, exception
);
2027 volatile struct gdb_exception result
;
2028 ptid_t previous_ptid
= inferior_ptid
;
2030 command
->token
= token
;
2034 command
->cmd_start
= (struct mi_timestamp
*)
2035 xmalloc (sizeof (struct mi_timestamp
));
2036 timestamp (command
->cmd_start
);
2039 TRY_CATCH (result
, RETURN_MASK_ALL
)
2041 captured_mi_execute_command (current_uiout
, command
);
2043 if (result
.reason
< 0)
2045 /* The command execution failed and error() was called
2047 mi_print_exception (command
->token
, result
);
2048 mi_out_rewind (current_uiout
);
2051 bpstat_do_actions ();
2053 if (/* The notifications are only output when the top-level
2054 interpreter (specified on the command line) is MI. */
2055 ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ()))
2056 /* Don't try report anything if there are no threads --
2057 the program is dead. */
2058 && thread_count () != 0
2059 /* -thread-select explicitly changes thread. If frontend uses that
2060 internally, we don't want to emit =thread-selected, since
2061 =thread-selected is supposed to indicate user's intentions. */
2062 && strcmp (command
->command
, "thread-select") != 0)
2064 struct mi_interp
*mi
= top_level_interpreter_data ();
2065 int report_change
= 0;
2067 if (command
->thread
== -1)
2069 report_change
= (!ptid_equal (previous_ptid
, null_ptid
)
2070 && !ptid_equal (inferior_ptid
, previous_ptid
)
2071 && !ptid_equal (inferior_ptid
, null_ptid
));
2073 else if (!ptid_equal (inferior_ptid
, null_ptid
))
2075 struct thread_info
*ti
= inferior_thread ();
2077 report_change
= (ti
->num
!= command
->thread
);
2082 struct thread_info
*ti
= inferior_thread ();
2084 target_terminal_ours ();
2085 fprintf_unfiltered (mi
->event_channel
,
2086 "thread-selected,id=\"%d\"",
2088 gdb_flush (mi
->event_channel
);
2092 mi_parse_free (command
);
2097 mi_cmd_execute (struct mi_parse
*parse
)
2099 struct cleanup
*cleanup
;
2101 cleanup
= prepare_execute_command ();
2103 if (parse
->all
&& parse
->thread_group
!= -1)
2104 error (_("Cannot specify --thread-group together with --all"));
2106 if (parse
->all
&& parse
->thread
!= -1)
2107 error (_("Cannot specify --thread together with --all"));
2109 if (parse
->thread_group
!= -1 && parse
->thread
!= -1)
2110 error (_("Cannot specify --thread together with --thread-group"));
2112 if (parse
->frame
!= -1 && parse
->thread
== -1)
2113 error (_("Cannot specify --frame without --thread"));
2115 if (parse
->thread_group
!= -1)
2117 struct inferior
*inf
= find_inferior_id (parse
->thread_group
);
2118 struct thread_info
*tp
= 0;
2121 error (_("Invalid thread group for the --thread-group option"));
2123 set_current_inferior (inf
);
2124 /* This behaviour means that if --thread-group option identifies
2125 an inferior with multiple threads, then a random one will be
2126 picked. This is not a problem -- frontend should always
2127 provide --thread if it wishes to operate on a specific
2130 tp
= any_live_thread_of_process (inf
->pid
);
2131 switch_to_thread (tp
? tp
->ptid
: null_ptid
);
2132 set_current_program_space (inf
->pspace
);
2135 if (parse
->thread
!= -1)
2137 struct thread_info
*tp
= find_thread_id (parse
->thread
);
2140 error (_("Invalid thread id: %d"), parse
->thread
);
2142 if (is_exited (tp
->ptid
))
2143 error (_("Thread id: %d has terminated"), parse
->thread
);
2145 switch_to_thread (tp
->ptid
);
2148 if (parse
->frame
!= -1)
2150 struct frame_info
*fid
;
2151 int frame
= parse
->frame
;
2153 fid
= find_relative_frame (get_current_frame (), &frame
);
2155 /* find_relative_frame was successful */
2158 error (_("Invalid frame id: %d"), frame
);
2161 current_context
= parse
;
2163 if (parse
->cmd
->suppress_notification
!= NULL
)
2165 make_cleanup_restore_integer (parse
->cmd
->suppress_notification
);
2166 *parse
->cmd
->suppress_notification
= 1;
2169 if (parse
->cmd
->argv_func
!= NULL
)
2171 parse
->cmd
->argv_func (parse
->command
, parse
->argv
, parse
->argc
);
2173 else if (parse
->cmd
->cli
.cmd
!= 0)
2175 /* FIXME: DELETE THIS. */
2176 /* The operation is still implemented by a cli command. */
2177 /* Must be a synchronous one. */
2178 mi_execute_cli_command (parse
->cmd
->cli
.cmd
, parse
->cmd
->cli
.args_p
,
2183 /* FIXME: DELETE THIS. */
2184 struct ui_file
*stb
;
2186 stb
= mem_fileopen ();
2188 fputs_unfiltered ("Undefined mi command: ", stb
);
2189 fputstr_unfiltered (parse
->command
, '"', stb
);
2190 fputs_unfiltered (" (missing implementation)", stb
);
2192 make_cleanup_ui_file_delete (stb
);
2195 do_cleanups (cleanup
);
2198 /* FIXME: This is just a hack so we can get some extra commands going.
2199 We don't want to channel things through the CLI, but call libgdb directly.
2200 Use only for synchronous commands. */
2203 mi_execute_cli_command (const char *cmd
, int args_p
, const char *args
)
2207 struct cleanup
*old_cleanups
;
2211 run
= xstrprintf ("%s %s", cmd
, args
);
2213 run
= xstrdup (cmd
);
2215 /* FIXME: gdb_???? */
2216 fprintf_unfiltered (gdb_stdout
, "cli=%s run=%s\n",
2218 old_cleanups
= make_cleanup (xfree
, run
);
2219 execute_command (run
, 0 /* from_tty */ );
2220 do_cleanups (old_cleanups
);
2226 mi_execute_async_cli_command (char *cli_command
, char **argv
, int argc
)
2228 struct cleanup
*old_cleanups
;
2231 if (target_can_async_p ())
2232 run
= xstrprintf ("%s %s&", cli_command
, argc
? *argv
: "");
2234 run
= xstrprintf ("%s %s", cli_command
, argc
? *argv
: "");
2235 old_cleanups
= make_cleanup (xfree
, run
);
2237 execute_command (run
, 0 /* from_tty */ );
2239 /* Do this before doing any printing. It would appear that some
2240 print code leaves garbage around in the buffer. */
2241 do_cleanups (old_cleanups
);
2245 mi_load_progress (const char *section_name
,
2246 unsigned long sent_so_far
,
2247 unsigned long total_section
,
2248 unsigned long total_sent
,
2249 unsigned long grand_total
)
2251 struct timeval time_now
, delta
, update_threshold
;
2252 static struct timeval last_update
;
2253 static char *previous_sect_name
= NULL
;
2255 struct ui_out
*saved_uiout
;
2256 struct ui_out
*uiout
;
2258 /* This function is called through deprecated_show_load_progress
2259 which means uiout may not be correct. Fix it for the duration
2260 of this function. */
2261 saved_uiout
= current_uiout
;
2263 if (current_interp_named_p (INTERP_MI
)
2264 || current_interp_named_p (INTERP_MI2
))
2265 current_uiout
= mi_out_new (2);
2266 else if (current_interp_named_p (INTERP_MI1
))
2267 current_uiout
= mi_out_new (1);
2268 else if (current_interp_named_p (INTERP_MI3
))
2269 current_uiout
= mi_out_new (3);
2273 uiout
= current_uiout
;
2275 update_threshold
.tv_sec
= 0;
2276 update_threshold
.tv_usec
= 500000;
2277 gettimeofday (&time_now
, NULL
);
2279 delta
.tv_usec
= time_now
.tv_usec
- last_update
.tv_usec
;
2280 delta
.tv_sec
= time_now
.tv_sec
- last_update
.tv_sec
;
2282 if (delta
.tv_usec
< 0)
2285 delta
.tv_usec
+= 1000000L;
2288 new_section
= (previous_sect_name
?
2289 strcmp (previous_sect_name
, section_name
) : 1);
2292 struct cleanup
*cleanup_tuple
;
2294 xfree (previous_sect_name
);
2295 previous_sect_name
= xstrdup (section_name
);
2298 fputs_unfiltered (current_token
, raw_stdout
);
2299 fputs_unfiltered ("+download", raw_stdout
);
2300 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2301 ui_out_field_string (uiout
, "section", section_name
);
2302 ui_out_field_int (uiout
, "section-size", total_section
);
2303 ui_out_field_int (uiout
, "total-size", grand_total
);
2304 do_cleanups (cleanup_tuple
);
2305 mi_out_put (uiout
, raw_stdout
);
2306 fputs_unfiltered ("\n", raw_stdout
);
2307 gdb_flush (raw_stdout
);
2310 if (delta
.tv_sec
>= update_threshold
.tv_sec
&&
2311 delta
.tv_usec
>= update_threshold
.tv_usec
)
2313 struct cleanup
*cleanup_tuple
;
2315 last_update
.tv_sec
= time_now
.tv_sec
;
2316 last_update
.tv_usec
= time_now
.tv_usec
;
2318 fputs_unfiltered (current_token
, raw_stdout
);
2319 fputs_unfiltered ("+download", raw_stdout
);
2320 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2321 ui_out_field_string (uiout
, "section", section_name
);
2322 ui_out_field_int (uiout
, "section-sent", sent_so_far
);
2323 ui_out_field_int (uiout
, "section-size", total_section
);
2324 ui_out_field_int (uiout
, "total-sent", total_sent
);
2325 ui_out_field_int (uiout
, "total-size", grand_total
);
2326 do_cleanups (cleanup_tuple
);
2327 mi_out_put (uiout
, raw_stdout
);
2328 fputs_unfiltered ("\n", raw_stdout
);
2329 gdb_flush (raw_stdout
);
2333 current_uiout
= saved_uiout
;
2337 timestamp (struct mi_timestamp
*tv
)
2339 gettimeofday (&tv
->wallclock
, NULL
);
2340 #ifdef HAVE_GETRUSAGE
2341 getrusage (RUSAGE_SELF
, &rusage
);
2342 tv
->utime
.tv_sec
= rusage
.ru_utime
.tv_sec
;
2343 tv
->utime
.tv_usec
= rusage
.ru_utime
.tv_usec
;
2344 tv
->stime
.tv_sec
= rusage
.ru_stime
.tv_sec
;
2345 tv
->stime
.tv_usec
= rusage
.ru_stime
.tv_usec
;
2348 long usec
= get_run_time ();
2350 tv
->utime
.tv_sec
= usec
/1000000L;
2351 tv
->utime
.tv_usec
= usec
- 1000000L*tv
->utime
.tv_sec
;
2352 tv
->stime
.tv_sec
= 0;
2353 tv
->stime
.tv_usec
= 0;
2359 print_diff_now (struct mi_timestamp
*start
)
2361 struct mi_timestamp now
;
2364 print_diff (start
, &now
);
2368 mi_print_timing_maybe (void)
2370 /* If the command is -enable-timing then do_timings may be true
2371 whilst current_command_ts is not initialized. */
2372 if (do_timings
&& current_command_ts
)
2373 print_diff_now (current_command_ts
);
2377 timeval_diff (struct timeval start
, struct timeval end
)
2379 return ((end
.tv_sec
- start
.tv_sec
) * 1000000L)
2380 + (end
.tv_usec
- start
.tv_usec
);
2384 print_diff (struct mi_timestamp
*start
, struct mi_timestamp
*end
)
2388 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
2389 timeval_diff (start
->wallclock
, end
->wallclock
) / 1000000.0,
2390 timeval_diff (start
->utime
, end
->utime
) / 1000000.0,
2391 timeval_diff (start
->stime
, end
->stime
) / 1000000.0);
2395 mi_cmd_trace_define_variable (char *command
, char **argv
, int argc
)
2397 struct expression
*expr
;
2398 LONGEST initval
= 0;
2399 struct trace_state_variable
*tsv
;
2402 if (argc
!= 1 && argc
!= 2)
2403 error (_("Usage: -trace-define-variable VARIABLE [VALUE]"));
2407 error (_("Name of trace variable should start with '$'"));
2409 validate_trace_state_variable_name (name
);
2411 tsv
= find_trace_state_variable (name
);
2413 tsv
= create_trace_state_variable (name
);
2416 initval
= value_as_long (parse_and_eval (argv
[1]));
2418 tsv
->initial_value
= initval
;
2422 mi_cmd_trace_list_variables (char *command
, char **argv
, int argc
)
2425 error (_("-trace-list-variables: no arguments allowed"));
2427 tvariables_info_1 ();
2431 mi_cmd_trace_find (char *command
, char **argv
, int argc
)
2436 error (_("trace selection mode is required"));
2440 if (strcmp (mode
, "none") == 0)
2442 tfind_1 (tfind_number
, -1, 0, 0, 0);
2446 if (current_trace_status ()->running
)
2447 error (_("May not look at trace frames while trace is running."));
2449 if (strcmp (mode
, "frame-number") == 0)
2452 error (_("frame number is required"));
2453 tfind_1 (tfind_number
, atoi (argv
[1]), 0, 0, 0);
2455 else if (strcmp (mode
, "tracepoint-number") == 0)
2458 error (_("tracepoint number is required"));
2459 tfind_1 (tfind_tp
, atoi (argv
[1]), 0, 0, 0);
2461 else if (strcmp (mode
, "pc") == 0)
2464 error (_("PC is required"));
2465 tfind_1 (tfind_pc
, 0, parse_and_eval_address (argv
[1]), 0, 0);
2467 else if (strcmp (mode
, "pc-inside-range") == 0)
2470 error (_("Start and end PC are required"));
2471 tfind_1 (tfind_range
, 0, parse_and_eval_address (argv
[1]),
2472 parse_and_eval_address (argv
[2]), 0);
2474 else if (strcmp (mode
, "pc-outside-range") == 0)
2477 error (_("Start and end PC are required"));
2478 tfind_1 (tfind_outside
, 0, parse_and_eval_address (argv
[1]),
2479 parse_and_eval_address (argv
[2]), 0);
2481 else if (strcmp (mode
, "line") == 0)
2483 struct symtabs_and_lines sals
;
2484 struct symtab_and_line sal
;
2485 static CORE_ADDR start_pc
, end_pc
;
2486 struct cleanup
*back_to
;
2489 error (_("Line is required"));
2491 sals
= decode_line_with_current_source (argv
[1],
2492 DECODE_LINE_FUNFIRSTLINE
);
2493 back_to
= make_cleanup (xfree
, sals
.sals
);
2497 if (sal
.symtab
== 0)
2498 error (_("Could not find the specified line"));
2500 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2501 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, 0);
2503 error (_("Could not find the specified line"));
2505 do_cleanups (back_to
);
2508 error (_("Invalid mode '%s'"), mode
);
2510 if (has_stack_frames () || get_traceframe_number () >= 0)
2511 print_stack_frame (get_selected_frame (NULL
), 1, SRC_AND_LOC
);
2515 mi_cmd_trace_save (char *command
, char **argv
, int argc
)
2517 int target_saves
= 0;
2518 int generate_ctf
= 0;
2525 TARGET_SAVE_OPT
, CTF_OPT
2527 static const struct mi_opt opts
[] =
2529 {"r", TARGET_SAVE_OPT
, 0},
2530 {"ctf", CTF_OPT
, 0},
2536 int opt
= mi_getopt ("-trace-save", argc
, argv
, opts
,
2541 switch ((enum opt
) opt
)
2543 case TARGET_SAVE_OPT
:
2551 filename
= argv
[oind
];
2554 trace_save_ctf (filename
, target_saves
);
2556 trace_save_tfile (filename
, target_saves
);
2560 mi_cmd_trace_start (char *command
, char **argv
, int argc
)
2562 start_tracing (NULL
);
2566 mi_cmd_trace_status (char *command
, char **argv
, int argc
)
2568 trace_status_mi (0);
2572 mi_cmd_trace_stop (char *command
, char **argv
, int argc
)
2574 stop_tracing (NULL
);
2575 trace_status_mi (1);
2578 /* Implement the "-ada-task-info" command. */
2581 mi_cmd_ada_task_info (char *command
, char **argv
, int argc
)
2583 if (argc
!= 0 && argc
!= 1)
2584 error (_("Invalid MI command"));
2586 print_ada_task_info (current_uiout
, argv
[0], current_inferior ());
2589 /* Print EXPRESSION according to VALUES. */
2592 print_variable_or_computed (char *expression
, enum print_values values
)
2594 struct expression
*expr
;
2595 struct cleanup
*old_chain
;
2597 struct ui_file
*stb
;
2598 struct value_print_options opts
;
2600 struct ui_out
*uiout
= current_uiout
;
2602 stb
= mem_fileopen ();
2603 old_chain
= make_cleanup_ui_file_delete (stb
);
2605 expr
= parse_expression (expression
);
2607 make_cleanup (free_current_contents
, &expr
);
2609 if (values
== PRINT_SIMPLE_VALUES
)
2610 val
= evaluate_type (expr
);
2612 val
= evaluate_expression (expr
);
2614 if (values
!= PRINT_NO_VALUES
)
2615 make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2616 ui_out_field_string (uiout
, "name", expression
);
2620 case PRINT_SIMPLE_VALUES
:
2621 type
= check_typedef (value_type (val
));
2622 type_print (value_type (val
), "", stb
, -1);
2623 ui_out_field_stream (uiout
, "type", stb
);
2624 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
2625 && TYPE_CODE (type
) != TYPE_CODE_STRUCT
2626 && TYPE_CODE (type
) != TYPE_CODE_UNION
)
2628 struct value_print_options opts
;
2630 get_no_prettyformat_print_options (&opts
);
2632 common_val_print (val
, stb
, 0, &opts
, current_language
);
2633 ui_out_field_stream (uiout
, "value", stb
);
2636 case PRINT_ALL_VALUES
:
2638 struct value_print_options opts
;
2640 get_no_prettyformat_print_options (&opts
);
2642 common_val_print (val
, stb
, 0, &opts
, current_language
);
2643 ui_out_field_stream (uiout
, "value", stb
);
2648 do_cleanups (old_chain
);
2651 /* Implement the "-trace-frame-collected" command. */
2654 mi_cmd_trace_frame_collected (char *command
, char **argv
, int argc
)
2656 struct cleanup
*old_chain
;
2657 struct bp_location
*tloc
;
2659 struct collection_list
*clist
;
2660 struct collection_list tracepoint_list
, stepping_list
;
2661 struct traceframe_info
*tinfo
;
2663 int var_print_values
= PRINT_ALL_VALUES
;
2664 int comp_print_values
= PRINT_ALL_VALUES
;
2665 int registers_format
= 'x';
2666 int memory_contents
= 0;
2667 struct ui_out
*uiout
= current_uiout
;
2675 static const struct mi_opt opts
[] =
2677 {"-var-print-values", VAR_PRINT_VALUES
, 1},
2678 {"-comp-print-values", COMP_PRINT_VALUES
, 1},
2679 {"-registers-format", REGISTERS_FORMAT
, 1},
2680 {"-memory-contents", MEMORY_CONTENTS
, 0},
2687 int opt
= mi_getopt ("-trace-frame-collected", argc
, argv
, opts
,
2691 switch ((enum opt
) opt
)
2693 case VAR_PRINT_VALUES
:
2694 var_print_values
= mi_parse_print_values (oarg
);
2696 case COMP_PRINT_VALUES
:
2697 comp_print_values
= mi_parse_print_values (oarg
);
2699 case REGISTERS_FORMAT
:
2700 registers_format
= oarg
[0];
2701 case MEMORY_CONTENTS
:
2702 memory_contents
= 1;
2708 error (_("Usage: -trace-frame-collected "
2709 "[--var-print-values PRINT_VALUES] "
2710 "[--comp-print-values PRINT_VALUES] "
2711 "[--registers-format FORMAT]"
2712 "[--memory-contents]"));
2714 /* This throws an error is not inspecting a trace frame. */
2715 tloc
= get_traceframe_location (&stepping_frame
);
2717 /* This command only makes sense for the current frame, not the
2719 old_chain
= make_cleanup_restore_current_thread ();
2720 select_frame (get_current_frame ());
2722 encode_actions_and_make_cleanup (tloc
, &tracepoint_list
,
2726 clist
= &stepping_list
;
2728 clist
= &tracepoint_list
;
2730 tinfo
= get_traceframe_info ();
2732 /* Explicitly wholly collected variables. */
2734 struct cleanup
*list_cleanup
;
2738 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
,
2739 "explicit-variables");
2740 for (i
= 0; VEC_iterate (char_ptr
, clist
->wholly_collected
, i
, p
); i
++)
2741 print_variable_or_computed (p
, var_print_values
);
2742 do_cleanups (list_cleanup
);
2745 /* Computed expressions. */
2747 struct cleanup
*list_cleanup
;
2752 = make_cleanup_ui_out_list_begin_end (uiout
,
2753 "computed-expressions");
2754 for (i
= 0; VEC_iterate (char_ptr
, clist
->computed
, i
, p
); i
++)
2755 print_variable_or_computed (p
, comp_print_values
);
2756 do_cleanups (list_cleanup
);
2759 /* Registers. Given pseudo-registers, and that some architectures
2760 (like MIPS) actually hide the raw registers, we don't go through
2761 the trace frame info, but instead consult the register cache for
2762 register availability. */
2764 struct cleanup
*list_cleanup
;
2765 struct frame_info
*frame
;
2766 struct gdbarch
*gdbarch
;
2770 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "registers");
2772 frame
= get_selected_frame (NULL
);
2773 gdbarch
= get_frame_arch (frame
);
2774 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
2776 for (regnum
= 0; regnum
< numregs
; regnum
++)
2778 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
2779 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
2782 output_register (frame
, regnum
, registers_format
, 1);
2785 do_cleanups (list_cleanup
);
2788 /* Trace state variables. */
2790 struct cleanup
*list_cleanup
;
2795 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "tvars");
2798 make_cleanup (free_current_contents
, &tsvname
);
2800 for (i
= 0; VEC_iterate (int, tinfo
->tvars
, i
, tvar
); i
++)
2802 struct cleanup
*cleanup_child
;
2803 struct trace_state_variable
*tsv
;
2805 tsv
= find_trace_state_variable_by_number (tvar
);
2807 cleanup_child
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2811 tsvname
= xrealloc (tsvname
, strlen (tsv
->name
) + 2);
2813 strcpy (tsvname
+ 1, tsv
->name
);
2814 ui_out_field_string (uiout
, "name", tsvname
);
2816 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
2818 ui_out_field_int (uiout
, "current", tsv
->value
);
2822 ui_out_field_skip (uiout
, "name");
2823 ui_out_field_skip (uiout
, "current");
2826 do_cleanups (cleanup_child
);
2829 do_cleanups (list_cleanup
);
2834 struct cleanup
*list_cleanup
;
2835 VEC(mem_range_s
) *available_memory
= NULL
;
2836 struct mem_range
*r
;
2839 traceframe_available_memory (&available_memory
, 0, ULONGEST_MAX
);
2840 make_cleanup (VEC_cleanup(mem_range_s
), &available_memory
);
2842 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "memory");
2844 for (i
= 0; VEC_iterate (mem_range_s
, available_memory
, i
, r
); i
++)
2846 struct cleanup
*cleanup_child
;
2848 struct gdbarch
*gdbarch
= target_gdbarch ();
2850 cleanup_child
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2852 ui_out_field_core_addr (uiout
, "address", gdbarch
, r
->start
);
2853 ui_out_field_int (uiout
, "length", r
->length
);
2855 data
= xmalloc (r
->length
);
2856 make_cleanup (xfree
, data
);
2858 if (memory_contents
)
2860 if (target_read_memory (r
->start
, data
, r
->length
) == 0)
2865 data_str
= xmalloc (r
->length
* 2 + 1);
2866 make_cleanup (xfree
, data_str
);
2868 for (m
= 0, p
= data_str
; m
< r
->length
; ++m
, p
+= 2)
2869 sprintf (p
, "%02x", data
[m
]);
2870 ui_out_field_string (uiout
, "contents", data_str
);
2873 ui_out_field_skip (uiout
, "contents");
2875 do_cleanups (cleanup_child
);
2878 do_cleanups (list_cleanup
);
2881 do_cleanups (old_chain
);