3 Copyright (C) 2000-2017 Free Software Foundation, Inc.
5 Contributed by Cygnus Solutions (a Red Hat company).
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "arch-utils.h"
28 #include "gdbthread.h"
31 #include "mi-getopt.h"
32 #include "mi-console.h"
36 #include "event-loop.h"
37 #include "event-top.h"
38 #include "gdbcore.h" /* For write_memory(). */
44 #include "mi-common.h"
49 #include "splay-tree.h"
50 #include "tracepoint.h"
54 #include "extension.h"
57 #include "common/gdb_optional.h"
60 #include "run-time-clock.h"
70 /* This is used to pass the current command timestamp down to
71 continuation routines. */
72 static struct mi_timestamp
*current_command_ts
;
74 static int do_timings
= 0;
77 /* Few commands would like to know if options like --thread-group were
78 explicitly specified. This variable keeps the current parsed
79 command including all option, and make it possible. */
80 static struct mi_parse
*current_context
;
82 int running_result_record_printed
= 1;
84 /* Flag indicating that the target has proceeded since the last
85 command was issued. */
88 extern void _initialize_mi_main (void);
89 static void mi_cmd_execute (struct mi_parse
*parse
);
91 static void mi_execute_cli_command (const char *cmd
, int args_p
,
93 static void mi_execute_async_cli_command (const char *cli_command
,
94 char **argv
, int argc
);
95 static int register_changed_p (int regnum
, struct regcache
*,
97 static void output_register (struct frame_info
*, int regnum
, int format
,
98 int skip_unavailable
);
100 /* Controls whether the frontend wants MI in async mode. */
101 static int mi_async
= 0;
103 /* The set command writes to this variable. If the inferior is
104 executing, mi_async is *not* updated. */
105 static int mi_async_1
= 0;
108 set_mi_async_command (char *args
, int from_tty
,
109 struct cmd_list_element
*c
)
111 if (have_live_inferiors ())
113 mi_async_1
= mi_async
;
114 error (_("Cannot change this setting while the inferior is running."));
117 mi_async
= mi_async_1
;
121 show_mi_async_command (struct ui_file
*file
, int from_tty
,
122 struct cmd_list_element
*c
,
125 fprintf_filtered (file
,
126 _("Whether MI is in asynchronous mode is %s.\n"),
130 /* A wrapper for target_can_async_p that takes the MI setting into
136 return mi_async
&& target_can_async_p ();
139 /* Command implementations. FIXME: Is this libgdb? No. This is the MI
140 layer that calls libgdb. Any operation used in the below should be
143 static void timestamp (struct mi_timestamp
*tv
);
145 static void print_diff (struct ui_file
*file
, struct mi_timestamp
*start
,
146 struct mi_timestamp
*end
);
149 mi_cmd_gdb_exit (const char *command
, char **argv
, int argc
)
151 struct mi_interp
*mi
= (struct mi_interp
*) current_interpreter ();
153 /* We have to print everything right here because we never return. */
155 fputs_unfiltered (current_token
, mi
->raw_stdout
);
156 fputs_unfiltered ("^exit\n", mi
->raw_stdout
);
157 mi_out_put (current_uiout
, mi
->raw_stdout
);
158 gdb_flush (mi
->raw_stdout
);
159 /* FIXME: The function called is not yet a formal libgdb function. */
160 quit_force (NULL
, FROM_TTY
);
164 mi_cmd_exec_next (const char *command
, char **argv
, int argc
)
166 /* FIXME: Should call a libgdb function, not a cli wrapper. */
167 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
168 mi_execute_async_cli_command ("reverse-next", argv
+ 1, argc
- 1);
170 mi_execute_async_cli_command ("next", argv
, argc
);
174 mi_cmd_exec_next_instruction (const char *command
, char **argv
, int argc
)
176 /* FIXME: Should call a libgdb function, not a cli wrapper. */
177 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
178 mi_execute_async_cli_command ("reverse-nexti", argv
+ 1, argc
- 1);
180 mi_execute_async_cli_command ("nexti", argv
, argc
);
184 mi_cmd_exec_step (const char *command
, char **argv
, int argc
)
186 /* FIXME: Should call a libgdb function, not a cli wrapper. */
187 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
188 mi_execute_async_cli_command ("reverse-step", argv
+ 1, argc
- 1);
190 mi_execute_async_cli_command ("step", argv
, argc
);
194 mi_cmd_exec_step_instruction (const char *command
, char **argv
, int argc
)
196 /* FIXME: Should call a libgdb function, not a cli wrapper. */
197 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
198 mi_execute_async_cli_command ("reverse-stepi", argv
+ 1, argc
- 1);
200 mi_execute_async_cli_command ("stepi", argv
, argc
);
204 mi_cmd_exec_finish (const char *command
, char **argv
, int argc
)
206 /* FIXME: Should call a libgdb function, not a cli wrapper. */
207 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
208 mi_execute_async_cli_command ("reverse-finish", argv
+ 1, argc
- 1);
210 mi_execute_async_cli_command ("finish", argv
, argc
);
214 mi_cmd_exec_return (const char *command
, char **argv
, int argc
)
216 /* This command doesn't really execute the target, it just pops the
217 specified number of frames. */
219 /* Call return_command with from_tty argument equal to 0 so as to
220 avoid being queried. */
221 return_command (*argv
, 0);
223 /* Call return_command with from_tty argument equal to 0 so as to
224 avoid being queried. */
225 return_command (NULL
, 0);
227 /* Because we have called return_command with from_tty = 0, we need
228 to print the frame here. */
229 print_stack_frame (get_selected_frame (NULL
), 1, LOC_AND_ADDRESS
, 1);
233 mi_cmd_exec_jump (const char *args
, char **argv
, int argc
)
235 /* FIXME: Should call a libgdb function, not a cli wrapper. */
236 mi_execute_async_cli_command ("jump", argv
, argc
);
240 proceed_thread (struct thread_info
*thread
, int pid
)
242 if (!is_stopped (thread
->ptid
))
245 if (pid
!= 0 && ptid_get_pid (thread
->ptid
) != pid
)
248 switch_to_thread (thread
->ptid
);
249 clear_proceed_status (0);
250 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
);
254 proceed_thread_callback (struct thread_info
*thread
, void *arg
)
256 int pid
= *(int *)arg
;
258 proceed_thread (thread
, pid
);
263 exec_continue (char **argv
, int argc
)
265 prepare_execution_command (¤t_target
, mi_async_p ());
269 /* In non-stop mode, 'resume' always resumes a single thread.
270 Therefore, to resume all threads of the current inferior, or
271 all threads in all inferiors, we need to iterate over
274 See comment on infcmd.c:proceed_thread_callback for rationale. */
275 if (current_context
->all
|| current_context
->thread_group
!= -1)
278 struct cleanup
*back_to
= make_cleanup_restore_current_thread ();
280 if (!current_context
->all
)
283 = find_inferior_id (current_context
->thread_group
);
287 iterate_over_threads (proceed_thread_callback
, &pid
);
288 do_cleanups (back_to
);
297 scoped_restore save_multi
= make_scoped_restore (&sched_multi
);
299 if (current_context
->all
)
306 /* In all-stop mode, -exec-continue traditionally resumed
307 either all threads, or one thread, depending on the
308 'scheduler-locking' variable. Let's continue to do the
316 exec_reverse_continue (char **argv
, int argc
)
318 enum exec_direction_kind dir
= execution_direction
;
320 if (dir
== EXEC_REVERSE
)
321 error (_("Already in reverse mode."));
323 if (!target_can_execute_reverse
)
324 error (_("Target %s does not support this command."), target_shortname
);
326 scoped_restore save_exec_dir
= make_scoped_restore (&execution_direction
,
328 exec_continue (argv
, argc
);
332 mi_cmd_exec_continue (const char *command
, char **argv
, int argc
)
334 if (argc
> 0 && strcmp (argv
[0], "--reverse") == 0)
335 exec_reverse_continue (argv
+ 1, argc
- 1);
337 exec_continue (argv
, argc
);
341 interrupt_thread_callback (struct thread_info
*thread
, void *arg
)
343 int pid
= *(int *)arg
;
345 if (!is_running (thread
->ptid
))
348 if (ptid_get_pid (thread
->ptid
) != pid
)
351 target_stop (thread
->ptid
);
355 /* Interrupt the execution of the target. Note how we must play
356 around with the token variables, in order to display the current
357 token in the result of the interrupt command, and the previous
358 execution token when the target finally stops. See comments in
362 mi_cmd_exec_interrupt (const char *command
, char **argv
, int argc
)
364 /* In all-stop mode, everything stops, so we don't need to try
365 anything specific. */
368 interrupt_target_1 (0);
372 if (current_context
->all
)
374 /* This will interrupt all threads in all inferiors. */
375 interrupt_target_1 (1);
377 else if (current_context
->thread_group
!= -1)
379 struct inferior
*inf
= find_inferior_id (current_context
->thread_group
);
381 iterate_over_threads (interrupt_thread_callback
, &inf
->pid
);
385 /* Interrupt just the current thread -- either explicitly
386 specified via --thread or whatever was current before
387 MI command was sent. */
388 interrupt_target_1 (0);
392 /* Callback for iterate_over_inferiors which starts the execution
393 of the given inferior.
395 ARG is a pointer to an integer whose value, if non-zero, indicates
396 that the program should be stopped when reaching the main subprogram
397 (similar to what the CLI "start" command does). */
400 run_one_inferior (struct inferior
*inf
, void *arg
)
402 int start_p
= *(int *) arg
;
403 const char *run_cmd
= start_p
? "start" : "run";
404 struct target_ops
*run_target
= find_run_target ();
405 int async_p
= mi_async
&& run_target
->to_can_async_p (run_target
);
409 if (inf
->pid
!= ptid_get_pid (inferior_ptid
))
411 struct thread_info
*tp
;
413 tp
= any_thread_of_process (inf
->pid
);
415 error (_("Inferior has no threads."));
417 switch_to_thread (tp
->ptid
);
422 set_current_inferior (inf
);
423 switch_to_thread (null_ptid
);
424 set_current_program_space (inf
->pspace
);
426 mi_execute_cli_command (run_cmd
, async_p
,
427 async_p
? "&" : NULL
);
432 mi_cmd_exec_run (const char *command
, char **argv
, int argc
)
436 /* Parse the command options. */
441 static const struct mi_opt opts
[] =
443 {"-start", START_OPT
, 0},
452 int opt
= mi_getopt ("-exec-run", argc
, argv
, opts
, &oind
, &oarg
);
456 switch ((enum opt
) opt
)
464 /* This command does not accept any argument. Make sure the user
465 did not provide any. */
467 error (_("Invalid argument: %s"), argv
[oind
]);
469 if (current_context
->all
)
471 struct cleanup
*back_to
= save_current_space_and_thread ();
473 iterate_over_inferiors (run_one_inferior
, &start_p
);
474 do_cleanups (back_to
);
478 const char *run_cmd
= start_p
? "start" : "run";
479 struct target_ops
*run_target
= find_run_target ();
480 int async_p
= mi_async
&& run_target
->to_can_async_p (run_target
);
482 mi_execute_cli_command (run_cmd
, async_p
,
483 async_p
? "&" : NULL
);
489 find_thread_of_process (struct thread_info
*ti
, void *p
)
493 if (ptid_get_pid (ti
->ptid
) == pid
&& !is_exited (ti
->ptid
))
500 mi_cmd_target_detach (const char *command
, char **argv
, int argc
)
502 if (argc
!= 0 && argc
!= 1)
503 error (_("Usage: -target-detach [pid | thread-group]"));
507 struct thread_info
*tp
;
511 /* First see if we are dealing with a thread-group id. */
514 struct inferior
*inf
;
515 int id
= strtoul (argv
[0] + 1, &end
, 0);
518 error (_("Invalid syntax of thread-group id '%s'"), argv
[0]);
520 inf
= find_inferior_id (id
);
522 error (_("Non-existent thread-group id '%d'"), id
);
528 /* We must be dealing with a pid. */
529 pid
= strtol (argv
[0], &end
, 10);
532 error (_("Invalid identifier '%s'"), argv
[0]);
535 /* Pick any thread in the desired process. Current
536 target_detach detaches from the parent of inferior_ptid. */
537 tp
= iterate_over_threads (find_thread_of_process
, &pid
);
539 error (_("Thread group is empty"));
541 switch_to_thread (tp
->ptid
);
544 detach_command (NULL
, 0);
548 mi_cmd_target_flash_erase (const char *command
, char **argv
, int argc
)
550 flash_erase_command (NULL
, 0);
554 mi_cmd_thread_select (const char *command
, char **argv
, int argc
)
557 char *mi_error_message
;
558 ptid_t previous_ptid
= inferior_ptid
;
561 error (_("-thread-select: USAGE: threadnum."));
563 rc
= gdb_thread_select (current_uiout
, argv
[0], &mi_error_message
);
565 /* If thread switch did not succeed don't notify or print. */
566 if (rc
== GDB_RC_FAIL
)
568 make_cleanup (xfree
, mi_error_message
);
569 error ("%s", mi_error_message
);
572 print_selected_thread_frame (current_uiout
,
573 USER_SELECTED_THREAD
| USER_SELECTED_FRAME
);
575 /* Notify if the thread has effectively changed. */
576 if (!ptid_equal (inferior_ptid
, previous_ptid
))
578 observer_notify_user_selected_context_changed (USER_SELECTED_THREAD
579 | USER_SELECTED_FRAME
);
584 mi_cmd_thread_list_ids (const char *command
, char **argv
, int argc
)
587 char *mi_error_message
;
590 error (_("-thread-list-ids: No arguments required."));
592 rc
= gdb_list_thread_ids (current_uiout
, &mi_error_message
);
594 if (rc
== GDB_RC_FAIL
)
596 make_cleanup (xfree
, mi_error_message
);
597 error ("%s", mi_error_message
);
602 mi_cmd_thread_info (const char *command
, char **argv
, int argc
)
604 if (argc
!= 0 && argc
!= 1)
605 error (_("Invalid MI command"));
607 print_thread_info (current_uiout
, argv
[0], -1);
610 struct collect_cores_data
618 collect_cores (struct thread_info
*ti
, void *xdata
)
620 struct collect_cores_data
*data
= (struct collect_cores_data
*) xdata
;
622 if (ptid_get_pid (ti
->ptid
) == data
->pid
)
624 int core
= target_core_of_thread (ti
->ptid
);
627 VEC_safe_push (int, data
->cores
, core
);
634 unique (int *b
, int *e
)
644 struct print_one_inferior_data
647 VEC (int) *inferiors
;
651 print_one_inferior (struct inferior
*inferior
, void *xdata
)
653 struct print_one_inferior_data
*top_data
654 = (struct print_one_inferior_data
*) xdata
;
655 struct ui_out
*uiout
= current_uiout
;
657 if (VEC_empty (int, top_data
->inferiors
)
658 || bsearch (&(inferior
->pid
), VEC_address (int, top_data
->inferiors
),
659 VEC_length (int, top_data
->inferiors
), sizeof (int),
660 compare_positive_ints
))
662 struct collect_cores_data data
;
663 struct cleanup
*back_to
664 = make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
666 uiout
->field_fmt ("id", "i%d", inferior
->num
);
667 uiout
->field_string ("type", "process");
668 if (inferior
->has_exit_code
)
669 uiout
->field_string ("exit-code",
670 int_string (inferior
->exit_code
, 8, 0, 0, 1));
671 if (inferior
->pid
!= 0)
672 uiout
->field_int ("pid", inferior
->pid
);
674 if (inferior
->pspace
->pspace_exec_filename
!= NULL
)
676 uiout
->field_string ("executable",
677 inferior
->pspace
->pspace_exec_filename
);
681 if (inferior
->pid
!= 0)
683 data
.pid
= inferior
->pid
;
684 iterate_over_threads (collect_cores
, &data
);
687 if (!VEC_empty (int, data
.cores
))
690 struct cleanup
*back_to_2
=
691 make_cleanup_ui_out_list_begin_end (uiout
, "cores");
693 qsort (VEC_address (int, data
.cores
),
694 VEC_length (int, data
.cores
), sizeof (int),
695 compare_positive_ints
);
697 b
= VEC_address (int, data
.cores
);
698 e
= b
+ VEC_length (int, data
.cores
);
702 uiout
->field_int (NULL
, *b
);
704 do_cleanups (back_to_2
);
707 if (top_data
->recurse
)
708 print_thread_info (uiout
, NULL
, inferior
->pid
);
710 do_cleanups (back_to
);
716 /* Output a field named 'cores' with a list as the value. The
717 elements of the list are obtained by splitting 'cores' on
721 output_cores (struct ui_out
*uiout
, const char *field_name
, const char *xcores
)
723 struct cleanup
*back_to
= make_cleanup_ui_out_list_begin_end (uiout
,
725 char *cores
= xstrdup (xcores
);
728 make_cleanup (xfree
, cores
);
730 for (p
= strtok (p
, ","); p
; p
= strtok (NULL
, ","))
731 uiout
->field_string (NULL
, p
);
733 do_cleanups (back_to
);
737 free_vector_of_ints (void *xvector
)
739 VEC (int) **vector
= (VEC (int) **) xvector
;
741 VEC_free (int, *vector
);
745 do_nothing (splay_tree_key k
)
750 free_vector_of_osdata_items (splay_tree_value xvalue
)
752 VEC (osdata_item_s
) *value
= (VEC (osdata_item_s
) *) xvalue
;
754 /* We don't free the items itself, it will be done separately. */
755 VEC_free (osdata_item_s
, value
);
759 splay_tree_int_comparator (splay_tree_key xa
, splay_tree_key xb
)
768 free_splay_tree (void *xt
)
770 splay_tree t
= (splay_tree
) xt
;
771 splay_tree_delete (t
);
775 list_available_thread_groups (VEC (int) *ids
, int recurse
)
778 struct osdata_item
*item
;
780 struct ui_out
*uiout
= current_uiout
;
781 struct cleanup
*cleanup
;
783 /* This keeps a map from integer (pid) to VEC (struct osdata_item *)*
784 The vector contains information about all threads for the given pid.
785 This is assigned an initial value to avoid "may be used uninitialized"
787 splay_tree tree
= NULL
;
789 /* get_osdata will throw if it cannot return data. */
790 data
= get_osdata ("processes");
791 cleanup
= make_cleanup_osdata_free (data
);
795 struct osdata
*threads
= get_osdata ("threads");
797 make_cleanup_osdata_free (threads
);
798 tree
= splay_tree_new (splay_tree_int_comparator
,
800 free_vector_of_osdata_items
);
801 make_cleanup (free_splay_tree
, tree
);
804 VEC_iterate (osdata_item_s
, threads
->items
,
808 const char *pid
= get_osdata_column (item
, "pid");
809 int pid_i
= strtoul (pid
, NULL
, 0);
810 VEC (osdata_item_s
) *vec
= 0;
812 splay_tree_node n
= splay_tree_lookup (tree
, pid_i
);
815 VEC_safe_push (osdata_item_s
, vec
, item
);
816 splay_tree_insert (tree
, pid_i
, (splay_tree_value
)vec
);
820 vec
= (VEC (osdata_item_s
) *) n
->value
;
821 VEC_safe_push (osdata_item_s
, vec
, item
);
822 n
->value
= (splay_tree_value
) vec
;
827 make_cleanup_ui_out_list_begin_end (uiout
, "groups");
830 VEC_iterate (osdata_item_s
, data
->items
,
834 struct cleanup
*back_to
;
836 const char *pid
= get_osdata_column (item
, "pid");
837 const char *cmd
= get_osdata_column (item
, "command");
838 const char *user
= get_osdata_column (item
, "user");
839 const char *cores
= get_osdata_column (item
, "cores");
841 int pid_i
= strtoul (pid
, NULL
, 0);
843 /* At present, the target will return all available processes
844 and if information about specific ones was required, we filter
845 undesired processes here. */
846 if (ids
&& bsearch (&pid_i
, VEC_address (int, ids
),
847 VEC_length (int, ids
),
848 sizeof (int), compare_positive_ints
) == NULL
)
852 back_to
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
854 uiout
->field_fmt ("id", "%s", pid
);
855 uiout
->field_string ("type", "process");
857 uiout
->field_string ("description", cmd
);
859 uiout
->field_string ("user", user
);
861 output_cores (uiout
, "cores", cores
);
865 splay_tree_node n
= splay_tree_lookup (tree
, pid_i
);
868 VEC (osdata_item_s
) *children
= (VEC (osdata_item_s
) *) n
->value
;
869 struct osdata_item
*child
;
872 make_cleanup_ui_out_list_begin_end (uiout
, "threads");
875 VEC_iterate (osdata_item_s
, children
, ix_child
, child
);
878 struct cleanup
*back_to_2
=
879 make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
880 const char *tid
= get_osdata_column (child
, "tid");
881 const char *tcore
= get_osdata_column (child
, "core");
883 uiout
->field_string ("id", tid
);
885 uiout
->field_string ("core", tcore
);
887 do_cleanups (back_to_2
);
892 do_cleanups (back_to
);
895 do_cleanups (cleanup
);
899 mi_cmd_list_thread_groups (const char *command
, char **argv
, int argc
)
901 struct ui_out
*uiout
= current_uiout
;
902 struct cleanup
*back_to
;
909 AVAILABLE_OPT
, RECURSE_OPT
911 static const struct mi_opt opts
[] =
913 {"-available", AVAILABLE_OPT
, 0},
914 {"-recurse", RECURSE_OPT
, 1},
923 int opt
= mi_getopt ("-list-thread-groups", argc
, argv
, opts
,
928 switch ((enum opt
) opt
)
934 if (strcmp (oarg
, "0") == 0)
936 else if (strcmp (oarg
, "1") == 0)
939 error (_("only '0' and '1' are valid values "
940 "for the '--recurse' option"));
945 for (; oind
< argc
; ++oind
)
950 if (*(argv
[oind
]) != 'i')
951 error (_("invalid syntax of group id '%s'"), argv
[oind
]);
953 inf
= strtoul (argv
[oind
] + 1, &end
, 0);
956 error (_("invalid syntax of group id '%s'"), argv
[oind
]);
957 VEC_safe_push (int, ids
, inf
);
959 if (VEC_length (int, ids
) > 1)
960 qsort (VEC_address (int, ids
),
961 VEC_length (int, ids
),
962 sizeof (int), compare_positive_ints
);
964 back_to
= make_cleanup (free_vector_of_ints
, &ids
);
968 list_available_thread_groups (ids
, recurse
);
970 else if (VEC_length (int, ids
) == 1)
972 /* Local thread groups, single id. */
973 int id
= *VEC_address (int, ids
);
974 struct inferior
*inf
= find_inferior_id (id
);
977 error (_("Non-existent thread group id '%d'"), id
);
979 print_thread_info (uiout
, NULL
, inf
->pid
);
983 struct print_one_inferior_data data
;
985 data
.recurse
= recurse
;
986 data
.inferiors
= ids
;
988 /* Local thread groups. Either no explicit ids -- and we
989 print everything, or several explicit ids. In both cases,
990 we print more than one group, and have to use 'groups'
991 as the top-level element. */
992 make_cleanup_ui_out_list_begin_end (uiout
, "groups");
993 update_thread_list ();
994 iterate_over_inferiors (print_one_inferior
, &data
);
997 do_cleanups (back_to
);
1001 mi_cmd_data_list_register_names (const char *command
, char **argv
, int argc
)
1003 struct gdbarch
*gdbarch
;
1004 struct ui_out
*uiout
= current_uiout
;
1005 int regnum
, numregs
;
1007 struct cleanup
*cleanup
;
1009 /* Note that the test for a valid register must include checking the
1010 gdbarch_register_name because gdbarch_num_regs may be allocated
1011 for the union of the register sets within a family of related
1012 processors. In this case, some entries of gdbarch_register_name
1013 will change depending upon the particular processor being
1016 gdbarch
= get_current_arch ();
1017 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1019 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "register-names");
1021 if (argc
== 0) /* No args, just do all the regs. */
1027 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1028 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1029 uiout
->field_string (NULL
, "");
1031 uiout
->field_string (NULL
, gdbarch_register_name (gdbarch
, regnum
));
1035 /* Else, list of register #s, just do listed regs. */
1036 for (i
= 0; i
< argc
; i
++)
1038 regnum
= atoi (argv
[i
]);
1039 if (regnum
< 0 || regnum
>= numregs
)
1040 error (_("bad register number"));
1042 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1043 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1044 uiout
->field_string (NULL
, "");
1046 uiout
->field_string (NULL
, gdbarch_register_name (gdbarch
, regnum
));
1048 do_cleanups (cleanup
);
1052 mi_cmd_data_list_changed_registers (const char *command
, char **argv
, int argc
)
1054 static struct regcache
*this_regs
= NULL
;
1055 struct ui_out
*uiout
= current_uiout
;
1056 struct regcache
*prev_regs
;
1057 struct gdbarch
*gdbarch
;
1058 int regnum
, numregs
, changed
;
1060 struct cleanup
*cleanup
;
1062 /* The last time we visited this function, the current frame's
1063 register contents were saved in THIS_REGS. Move THIS_REGS over
1064 to PREV_REGS, and refresh THIS_REGS with the now-current register
1067 prev_regs
= this_regs
;
1068 this_regs
= frame_save_as_regcache (get_selected_frame (NULL
));
1069 cleanup
= make_cleanup_regcache_xfree (prev_regs
);
1071 /* Note that the test for a valid register must include checking the
1072 gdbarch_register_name because gdbarch_num_regs may be allocated
1073 for the union of the register sets within a family of related
1074 processors. In this case, some entries of gdbarch_register_name
1075 will change depending upon the particular processor being
1078 gdbarch
= get_regcache_arch (this_regs
);
1079 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1081 make_cleanup_ui_out_list_begin_end (uiout
, "changed-registers");
1085 /* No args, just do all the regs. */
1090 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1091 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1093 changed
= register_changed_p (regnum
, prev_regs
, this_regs
);
1095 error (_("-data-list-changed-registers: "
1096 "Unable to read register contents."));
1098 uiout
->field_int (NULL
, regnum
);
1102 /* Else, list of register #s, just do listed regs. */
1103 for (i
= 0; i
< argc
; i
++)
1105 regnum
= atoi (argv
[i
]);
1109 && gdbarch_register_name (gdbarch
, regnum
) != NULL
1110 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
1112 changed
= register_changed_p (regnum
, prev_regs
, this_regs
);
1114 error (_("-data-list-changed-registers: "
1115 "Unable to read register contents."));
1117 uiout
->field_int (NULL
, regnum
);
1120 error (_("bad register number"));
1122 do_cleanups (cleanup
);
1126 register_changed_p (int regnum
, struct regcache
*prev_regs
,
1127 struct regcache
*this_regs
)
1129 struct gdbarch
*gdbarch
= get_regcache_arch (this_regs
);
1130 gdb_byte prev_buffer
[MAX_REGISTER_SIZE
];
1131 gdb_byte this_buffer
[MAX_REGISTER_SIZE
];
1132 enum register_status prev_status
;
1133 enum register_status this_status
;
1135 /* First time through or after gdbarch change consider all registers
1137 if (!prev_regs
|| get_regcache_arch (prev_regs
) != gdbarch
)
1140 /* Get register contents and compare. */
1141 prev_status
= regcache_cooked_read (prev_regs
, regnum
, prev_buffer
);
1142 this_status
= regcache_cooked_read (this_regs
, regnum
, this_buffer
);
1144 if (this_status
!= prev_status
)
1146 else if (this_status
== REG_VALID
)
1147 return memcmp (prev_buffer
, this_buffer
,
1148 register_size (gdbarch
, regnum
)) != 0;
1153 /* Return a list of register number and value pairs. The valid
1154 arguments expected are: a letter indicating the format in which to
1155 display the registers contents. This can be one of: x
1156 (hexadecimal), d (decimal), N (natural), t (binary), o (octal), r
1157 (raw). After the format argument there can be a sequence of
1158 numbers, indicating which registers to fetch the content of. If
1159 the format is the only argument, a list of all the registers with
1160 their values is returned. */
1163 mi_cmd_data_list_register_values (const char *command
, char **argv
, int argc
)
1165 struct ui_out
*uiout
= current_uiout
;
1166 struct frame_info
*frame
;
1167 struct gdbarch
*gdbarch
;
1168 int regnum
, numregs
, format
;
1170 struct cleanup
*list_cleanup
;
1171 int skip_unavailable
= 0;
1177 static const struct mi_opt opts
[] =
1179 {"-skip-unavailable", SKIP_UNAVAILABLE
, 0},
1183 /* Note that the test for a valid register must include checking the
1184 gdbarch_register_name because gdbarch_num_regs may be allocated
1185 for the union of the register sets within a family of related
1186 processors. In this case, some entries of gdbarch_register_name
1187 will change depending upon the particular processor being
1193 int opt
= mi_getopt ("-data-list-register-values", argc
, argv
,
1194 opts
, &oind
, &oarg
);
1198 switch ((enum opt
) opt
)
1200 case SKIP_UNAVAILABLE
:
1201 skip_unavailable
= 1;
1206 if (argc
- oind
< 1)
1207 error (_("-data-list-register-values: Usage: "
1208 "-data-list-register-values [--skip-unavailable] <format>"
1209 " [<regnum1>...<regnumN>]"));
1211 format
= (int) argv
[oind
][0];
1213 frame
= get_selected_frame (NULL
);
1214 gdbarch
= get_frame_arch (frame
);
1215 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1217 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "register-values");
1219 if (argc
- oind
== 1)
1221 /* No args, beside the format: do all the regs. */
1226 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1227 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1230 output_register (frame
, regnum
, format
, skip_unavailable
);
1234 /* Else, list of register #s, just do listed regs. */
1235 for (i
= 1 + oind
; i
< argc
; i
++)
1237 regnum
= atoi (argv
[i
]);
1241 && gdbarch_register_name (gdbarch
, regnum
) != NULL
1242 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
1243 output_register (frame
, regnum
, format
, skip_unavailable
);
1245 error (_("bad register number"));
1247 do_cleanups (list_cleanup
);
1250 /* Output one register REGNUM's contents in the desired FORMAT. If
1251 SKIP_UNAVAILABLE is true, skip the register if it is
1255 output_register (struct frame_info
*frame
, int regnum
, int format
,
1256 int skip_unavailable
)
1258 struct ui_out
*uiout
= current_uiout
;
1259 struct value
*val
= value_of_register (regnum
, frame
);
1260 struct cleanup
*tuple_cleanup
;
1261 struct value_print_options opts
;
1263 if (skip_unavailable
&& !value_entirely_available (val
))
1266 tuple_cleanup
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1267 uiout
->field_int ("number", regnum
);
1277 get_formatted_print_options (&opts
, format
);
1279 val_print (value_type (val
),
1280 value_embedded_offset (val
), 0,
1281 &stb
, 0, val
, &opts
, current_language
);
1282 uiout
->field_stream ("value", stb
);
1284 do_cleanups (tuple_cleanup
);
1287 /* Write given values into registers. The registers and values are
1288 given as pairs. The corresponding MI command is
1289 -data-write-register-values <format>
1290 [<regnum1> <value1>...<regnumN> <valueN>] */
1292 mi_cmd_data_write_register_values (const char *command
, char **argv
, int argc
)
1294 struct regcache
*regcache
;
1295 struct gdbarch
*gdbarch
;
1298 /* Note that the test for a valid register must include checking the
1299 gdbarch_register_name because gdbarch_num_regs may be allocated
1300 for the union of the register sets within a family of related
1301 processors. In this case, some entries of gdbarch_register_name
1302 will change depending upon the particular processor being
1305 regcache
= get_current_regcache ();
1306 gdbarch
= get_regcache_arch (regcache
);
1307 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1310 error (_("-data-write-register-values: Usage: -data-write-register-"
1311 "values <format> [<regnum1> <value1>...<regnumN> <valueN>]"));
1313 if (!target_has_registers
)
1314 error (_("-data-write-register-values: No registers."));
1317 error (_("-data-write-register-values: No regs and values specified."));
1320 error (_("-data-write-register-values: "
1321 "Regs and vals are not in pairs."));
1323 for (i
= 1; i
< argc
; i
= i
+ 2)
1325 int regnum
= atoi (argv
[i
]);
1327 if (regnum
>= 0 && regnum
< numregs
1328 && gdbarch_register_name (gdbarch
, regnum
)
1329 && *gdbarch_register_name (gdbarch
, regnum
))
1333 /* Get the value as a number. */
1334 value
= parse_and_eval_address (argv
[i
+ 1]);
1336 /* Write it down. */
1337 regcache_cooked_write_signed (regcache
, regnum
, value
);
1340 error (_("bad register number"));
1344 /* Evaluate the value of the argument. The argument is an
1345 expression. If the expression contains spaces it needs to be
1346 included in double quotes. */
1349 mi_cmd_data_evaluate_expression (const char *command
, char **argv
, int argc
)
1352 struct value_print_options opts
;
1353 struct ui_out
*uiout
= current_uiout
;
1356 error (_("-data-evaluate-expression: "
1357 "Usage: -data-evaluate-expression expression"));
1359 expression_up expr
= parse_expression (argv
[0]);
1361 val
= evaluate_expression (expr
.get ());
1365 /* Print the result of the expression evaluation. */
1366 get_user_print_options (&opts
);
1368 common_val_print (val
, &stb
, 0, &opts
, current_language
);
1370 uiout
->field_stream ("value", stb
);
1373 /* This is the -data-read-memory command.
1375 ADDR: start address of data to be dumped.
1376 WORD-FORMAT: a char indicating format for the ``word''. See
1378 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
1379 NR_ROW: Number of rows.
1380 NR_COL: The number of colums (words per row).
1381 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
1382 ASCHAR for unprintable characters.
1384 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
1385 displayes them. Returns:
1387 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
1390 The number of bytes read is SIZE*ROW*COL. */
1393 mi_cmd_data_read_memory (const char *command
, char **argv
, int argc
)
1395 struct gdbarch
*gdbarch
= get_current_arch ();
1396 struct ui_out
*uiout
= current_uiout
;
1398 long total_bytes
, nr_cols
, nr_rows
;
1400 struct type
*word_type
;
1412 static const struct mi_opt opts
[] =
1414 {"o", OFFSET_OPT
, 1},
1420 int opt
= mi_getopt ("-data-read-memory", argc
, argv
, opts
,
1425 switch ((enum opt
) opt
)
1428 offset
= atol (oarg
);
1435 if (argc
< 5 || argc
> 6)
1436 error (_("-data-read-memory: Usage: "
1437 "ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR]."));
1439 /* Extract all the arguments. */
1441 /* Start address of the memory dump. */
1442 addr
= parse_and_eval_address (argv
[0]) + offset
;
1443 /* The format character to use when displaying a memory word. See
1444 the ``x'' command. */
1445 word_format
= argv
[1][0];
1446 /* The size of the memory word. */
1447 word_size
= atol (argv
[2]);
1451 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1455 word_type
= builtin_type (gdbarch
)->builtin_int16
;
1459 word_type
= builtin_type (gdbarch
)->builtin_int32
;
1463 word_type
= builtin_type (gdbarch
)->builtin_int64
;
1467 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1470 /* The number of rows. */
1471 nr_rows
= atol (argv
[3]);
1473 error (_("-data-read-memory: invalid number of rows."));
1475 /* Number of bytes per row. */
1476 nr_cols
= atol (argv
[4]);
1478 error (_("-data-read-memory: invalid number of columns."));
1480 /* The un-printable character when printing ascii. */
1486 /* Create a buffer and read it in. */
1487 total_bytes
= word_size
* nr_rows
* nr_cols
;
1489 std::unique_ptr
<gdb_byte
[]> mbuf (new gdb_byte
[total_bytes
]);
1491 /* Dispatch memory reads to the topmost target, not the flattened
1493 nr_bytes
= target_read (current_target
.beneath
,
1494 TARGET_OBJECT_MEMORY
, NULL
, mbuf
.get (),
1497 error (_("Unable to read memory."));
1499 /* Output the header information. */
1500 uiout
->field_core_addr ("addr", gdbarch
, addr
);
1501 uiout
->field_int ("nr-bytes", nr_bytes
);
1502 uiout
->field_int ("total-bytes", total_bytes
);
1503 uiout
->field_core_addr ("next-row", gdbarch
, addr
+ word_size
* nr_cols
);
1504 uiout
->field_core_addr ("prev-row", gdbarch
, addr
- word_size
* nr_cols
);
1505 uiout
->field_core_addr ("next-page", gdbarch
, addr
+ total_bytes
);
1506 uiout
->field_core_addr ("prev-page", gdbarch
, addr
- total_bytes
);
1508 /* Build the result as a two dimentional table. */
1512 struct cleanup
*cleanup_list
;
1516 cleanup_list
= make_cleanup_ui_out_list_begin_end (uiout
, "memory");
1517 for (row
= 0, row_byte
= 0;
1519 row
++, row_byte
+= nr_cols
* word_size
)
1523 struct cleanup
*cleanup_tuple
;
1524 struct cleanup
*cleanup_list_data
;
1525 struct value_print_options opts
;
1527 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1528 uiout
->field_core_addr ("addr", gdbarch
, addr
+ row_byte
);
1529 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr +
1531 cleanup_list_data
= make_cleanup_ui_out_list_begin_end (uiout
, "data");
1532 get_formatted_print_options (&opts
, word_format
);
1533 for (col
= 0, col_byte
= row_byte
;
1535 col
++, col_byte
+= word_size
)
1537 if (col_byte
+ word_size
> nr_bytes
)
1539 uiout
->field_string (NULL
, "N/A");
1544 print_scalar_formatted (&mbuf
[col_byte
], word_type
, &opts
,
1545 word_asize
, &stream
);
1546 uiout
->field_stream (NULL
, stream
);
1549 do_cleanups (cleanup_list_data
);
1555 for (byte
= row_byte
;
1556 byte
< row_byte
+ word_size
* nr_cols
; byte
++)
1558 if (byte
>= nr_bytes
)
1560 else if (mbuf
[byte
] < 32 || mbuf
[byte
] > 126)
1561 stream
.putc (aschar
);
1563 stream
.putc (mbuf
[byte
]);
1565 uiout
->field_stream ("ascii", stream
);
1567 do_cleanups (cleanup_tuple
);
1569 do_cleanups (cleanup_list
);
1574 mi_cmd_data_read_memory_bytes (const char *command
, char **argv
, int argc
)
1576 struct gdbarch
*gdbarch
= get_current_arch ();
1577 struct ui_out
*uiout
= current_uiout
;
1578 struct cleanup
*cleanups
;
1581 memory_read_result_s
*read_result
;
1583 VEC(memory_read_result_s
) *result
;
1585 int unit_size
= gdbarch_addressable_memory_unit_size (gdbarch
);
1592 static const struct mi_opt opts
[] =
1594 {"o", OFFSET_OPT
, 1},
1600 int opt
= mi_getopt ("-data-read-memory-bytes", argc
, argv
, opts
,
1604 switch ((enum opt
) opt
)
1607 offset
= atol (oarg
);
1615 error (_("Usage: [ -o OFFSET ] ADDR LENGTH."));
1617 addr
= parse_and_eval_address (argv
[0]) + offset
;
1618 length
= atol (argv
[1]);
1620 result
= read_memory_robust (current_target
.beneath
, addr
, length
);
1622 cleanups
= make_cleanup (free_memory_read_result_vector
, &result
);
1624 if (VEC_length (memory_read_result_s
, result
) == 0)
1625 error (_("Unable to read memory."));
1627 make_cleanup_ui_out_list_begin_end (uiout
, "memory");
1629 VEC_iterate (memory_read_result_s
, result
, ix
, read_result
);
1632 struct cleanup
*t
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1637 uiout
->field_core_addr ("begin", gdbarch
, read_result
->begin
);
1638 uiout
->field_core_addr ("offset", gdbarch
, read_result
->begin
- addr
);
1639 uiout
->field_core_addr ("end", gdbarch
, read_result
->end
);
1641 alloc_len
= (read_result
->end
- read_result
->begin
) * 2 * unit_size
+ 1;
1642 data
= (char *) xmalloc (alloc_len
);
1644 for (i
= 0, p
= data
;
1645 i
< ((read_result
->end
- read_result
->begin
) * unit_size
);
1648 sprintf (p
, "%02x", read_result
->data
[i
]);
1650 uiout
->field_string ("contents", data
);
1654 do_cleanups (cleanups
);
1657 /* Implementation of the -data-write_memory command.
1659 COLUMN_OFFSET: optional argument. Must be preceded by '-o'. The
1660 offset from the beginning of the memory grid row where the cell to
1662 ADDR: start address of the row in the memory grid where the memory
1663 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
1664 the location to write to.
1665 FORMAT: a char indicating format for the ``word''. See
1667 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
1668 VALUE: value to be written into the memory address.
1670 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1675 mi_cmd_data_write_memory (const char *command
, char **argv
, int argc
)
1677 struct gdbarch
*gdbarch
= get_current_arch ();
1678 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1681 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1682 enough when using a compiler other than GCC. */
1685 struct cleanup
*old_chain
;
1693 static const struct mi_opt opts
[] =
1695 {"o", OFFSET_OPT
, 1},
1701 int opt
= mi_getopt ("-data-write-memory", argc
, argv
, opts
,
1706 switch ((enum opt
) opt
)
1709 offset
= atol (oarg
);
1717 error (_("-data-write-memory: Usage: "
1718 "[-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE."));
1720 /* Extract all the arguments. */
1721 /* Start address of the memory dump. */
1722 addr
= parse_and_eval_address (argv
[0]);
1723 /* The size of the memory word. */
1724 word_size
= atol (argv
[2]);
1726 /* Calculate the real address of the write destination. */
1727 addr
+= (offset
* word_size
);
1729 /* Get the value as a number. */
1730 value
= parse_and_eval_address (argv
[3]);
1731 /* Get the value into an array. */
1732 buffer
= (gdb_byte
*) xmalloc (word_size
);
1733 old_chain
= make_cleanup (xfree
, buffer
);
1734 store_signed_integer (buffer
, word_size
, byte_order
, value
);
1735 /* Write it down to memory. */
1736 write_memory_with_notification (addr
, buffer
, word_size
);
1737 /* Free the buffer. */
1738 do_cleanups (old_chain
);
1741 /* Implementation of the -data-write-memory-bytes command.
1744 DATA: string of bytes to write at that address
1745 COUNT: number of bytes to be filled (decimal integer). */
1748 mi_cmd_data_write_memory_bytes (const char *command
, char **argv
, int argc
)
1754 size_t len_hex
, len_bytes
, len_units
, i
, steps
, remaining_units
;
1755 long int count_units
;
1756 struct cleanup
*back_to
;
1759 if (argc
!= 2 && argc
!= 3)
1760 error (_("Usage: ADDR DATA [COUNT]."));
1762 addr
= parse_and_eval_address (argv
[0]);
1764 len_hex
= strlen (cdata
);
1765 unit_size
= gdbarch_addressable_memory_unit_size (get_current_arch ());
1767 if (len_hex
% (unit_size
* 2) != 0)
1768 error (_("Hex-encoded '%s' must represent an integral number of "
1769 "addressable memory units."),
1772 len_bytes
= len_hex
/ 2;
1773 len_units
= len_bytes
/ unit_size
;
1776 count_units
= strtoul (argv
[2], NULL
, 10);
1778 count_units
= len_units
;
1780 databuf
= XNEWVEC (gdb_byte
, len_bytes
);
1781 back_to
= make_cleanup (xfree
, databuf
);
1783 for (i
= 0; i
< len_bytes
; ++i
)
1786 if (sscanf (cdata
+ i
* 2, "%02x", &x
) != 1)
1787 error (_("Invalid argument"));
1788 databuf
[i
] = (gdb_byte
) x
;
1791 if (len_units
< count_units
)
1793 /* Pattern is made of less units than count:
1794 repeat pattern to fill memory. */
1795 data
= (gdb_byte
*) xmalloc (count_units
* unit_size
);
1796 make_cleanup (xfree
, data
);
1798 /* Number of times the pattern is entirely repeated. */
1799 steps
= count_units
/ len_units
;
1800 /* Number of remaining addressable memory units. */
1801 remaining_units
= count_units
% len_units
;
1802 for (i
= 0; i
< steps
; i
++)
1803 memcpy (data
+ i
* len_bytes
, databuf
, len_bytes
);
1805 if (remaining_units
> 0)
1806 memcpy (data
+ steps
* len_bytes
, databuf
,
1807 remaining_units
* unit_size
);
1811 /* Pattern is longer than or equal to count:
1812 just copy count addressable memory units. */
1816 write_memory_with_notification (addr
, data
, count_units
);
1818 do_cleanups (back_to
);
1822 mi_cmd_enable_timings (const char *command
, char **argv
, int argc
)
1828 if (strcmp (argv
[0], "yes") == 0)
1830 else if (strcmp (argv
[0], "no") == 0)
1841 error (_("-enable-timings: Usage: %s {yes|no}"), command
);
1845 mi_cmd_list_features (const char *command
, char **argv
, int argc
)
1849 struct cleanup
*cleanup
= NULL
;
1850 struct ui_out
*uiout
= current_uiout
;
1852 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "features");
1853 uiout
->field_string (NULL
, "frozen-varobjs");
1854 uiout
->field_string (NULL
, "pending-breakpoints");
1855 uiout
->field_string (NULL
, "thread-info");
1856 uiout
->field_string (NULL
, "data-read-memory-bytes");
1857 uiout
->field_string (NULL
, "breakpoint-notifications");
1858 uiout
->field_string (NULL
, "ada-task-info");
1859 uiout
->field_string (NULL
, "language-option");
1860 uiout
->field_string (NULL
, "info-gdb-mi-command");
1861 uiout
->field_string (NULL
, "undefined-command-error-code");
1862 uiout
->field_string (NULL
, "exec-run-start-option");
1864 if (ext_lang_initialized_p (get_ext_lang_defn (EXT_LANG_PYTHON
)))
1865 uiout
->field_string (NULL
, "python");
1867 do_cleanups (cleanup
);
1871 error (_("-list-features should be passed no arguments"));
1875 mi_cmd_list_target_features (const char *command
, char **argv
, int argc
)
1879 struct cleanup
*cleanup
= NULL
;
1880 struct ui_out
*uiout
= current_uiout
;
1882 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "features");
1884 uiout
->field_string (NULL
, "async");
1885 if (target_can_execute_reverse
)
1886 uiout
->field_string (NULL
, "reverse");
1887 do_cleanups (cleanup
);
1891 error (_("-list-target-features should be passed no arguments"));
1895 mi_cmd_add_inferior (const char *command
, char **argv
, int argc
)
1897 struct inferior
*inf
;
1900 error (_("-add-inferior should be passed no arguments"));
1902 inf
= add_inferior_with_spaces ();
1904 current_uiout
->field_fmt ("inferior", "i%d", inf
->num
);
1907 /* Callback used to find the first inferior other than the current
1911 get_other_inferior (struct inferior
*inf
, void *arg
)
1913 if (inf
== current_inferior ())
1920 mi_cmd_remove_inferior (const char *command
, char **argv
, int argc
)
1923 struct inferior
*inf
;
1926 error (_("-remove-inferior should be passed a single argument"));
1928 if (sscanf (argv
[0], "i%d", &id
) != 1)
1929 error (_("the thread group id is syntactically invalid"));
1931 inf
= find_inferior_id (id
);
1933 error (_("the specified thread group does not exist"));
1936 error (_("cannot remove an active inferior"));
1938 if (inf
== current_inferior ())
1940 struct thread_info
*tp
= 0;
1941 struct inferior
*new_inferior
1942 = iterate_over_inferiors (get_other_inferior
, NULL
);
1944 if (new_inferior
== NULL
)
1945 error (_("Cannot remove last inferior"));
1947 set_current_inferior (new_inferior
);
1948 if (new_inferior
->pid
!= 0)
1949 tp
= any_thread_of_process (new_inferior
->pid
);
1950 switch_to_thread (tp
? tp
->ptid
: null_ptid
);
1951 set_current_program_space (new_inferior
->pspace
);
1954 delete_inferior (inf
);
1959 /* Execute a command within a safe environment.
1960 Return <0 for error; >=0 for ok.
1962 args->action will tell mi_execute_command what action
1963 to perfrom after the given command has executed (display/suppress
1964 prompt, display error). */
1967 captured_mi_execute_command (struct ui_out
*uiout
, struct mi_parse
*context
)
1969 struct mi_interp
*mi
= (struct mi_interp
*) command_interp ();
1970 struct cleanup
*cleanup
;
1973 current_command_ts
= context
->cmd_start
;
1975 current_token
= xstrdup (context
->token
);
1976 cleanup
= make_cleanup (free_current_contents
, ¤t_token
);
1978 running_result_record_printed
= 0;
1980 switch (context
->op
)
1983 /* A MI command was read from the input stream. */
1985 /* FIXME: gdb_???? */
1986 fprintf_unfiltered (mi
->raw_stdout
,
1987 " token=`%s' command=`%s' args=`%s'\n",
1988 context
->token
, context
->command
, context
->args
);
1990 mi_cmd_execute (context
);
1992 /* Print the result if there were no errors.
1994 Remember that on the way out of executing a command, you have
1995 to directly use the mi_interp's uiout, since the command
1996 could have reset the interpreter, in which case the current
1997 uiout will most likely crash in the mi_out_* routines. */
1998 if (!running_result_record_printed
)
2000 fputs_unfiltered (context
->token
, mi
->raw_stdout
);
2001 /* There's no particularly good reason why target-connect results
2002 in not ^done. Should kill ^connected for MI3. */
2003 fputs_unfiltered (strcmp (context
->command
, "target-select") == 0
2004 ? "^connected" : "^done", mi
->raw_stdout
);
2005 mi_out_put (uiout
, mi
->raw_stdout
);
2006 mi_out_rewind (uiout
);
2007 mi_print_timing_maybe (mi
->raw_stdout
);
2008 fputs_unfiltered ("\n", mi
->raw_stdout
);
2011 /* The command does not want anything to be printed. In that
2012 case, the command probably should not have written anything
2013 to uiout, but in case it has written something, discard it. */
2014 mi_out_rewind (uiout
);
2021 /* A CLI command was read from the input stream. */
2022 /* This "feature" will be removed as soon as we have a
2023 complete set of mi commands. */
2024 /* Echo the command on the console. */
2025 fprintf_unfiltered (gdb_stdlog
, "%s\n", context
->command
);
2026 /* Call the "console" interpreter. */
2027 argv
[0] = (char *) INTERP_CONSOLE
;
2028 argv
[1] = context
->command
;
2029 mi_cmd_interpreter_exec ("-interpreter-exec", argv
, 2);
2031 /* If we changed interpreters, DON'T print out anything. */
2032 if (current_interp_named_p (INTERP_MI
)
2033 || current_interp_named_p (INTERP_MI1
)
2034 || current_interp_named_p (INTERP_MI2
)
2035 || current_interp_named_p (INTERP_MI3
))
2037 if (!running_result_record_printed
)
2039 fputs_unfiltered (context
->token
, mi
->raw_stdout
);
2040 fputs_unfiltered ("^done", mi
->raw_stdout
);
2041 mi_out_put (uiout
, mi
->raw_stdout
);
2042 mi_out_rewind (uiout
);
2043 mi_print_timing_maybe (mi
->raw_stdout
);
2044 fputs_unfiltered ("\n", mi
->raw_stdout
);
2047 mi_out_rewind (uiout
);
2053 do_cleanups (cleanup
);
2056 /* Print a gdb exception to the MI output stream. */
2059 mi_print_exception (const char *token
, struct gdb_exception exception
)
2061 struct mi_interp
*mi
= (struct mi_interp
*) current_interpreter ();
2063 fputs_unfiltered (token
, mi
->raw_stdout
);
2064 fputs_unfiltered ("^error,msg=\"", mi
->raw_stdout
);
2065 if (exception
.message
== NULL
)
2066 fputs_unfiltered ("unknown error", mi
->raw_stdout
);
2068 fputstr_unfiltered (exception
.message
, '"', mi
->raw_stdout
);
2069 fputs_unfiltered ("\"", mi
->raw_stdout
);
2071 switch (exception
.error
)
2073 case UNDEFINED_COMMAND_ERROR
:
2074 fputs_unfiltered (",code=\"undefined-command\"", mi
->raw_stdout
);
2078 fputs_unfiltered ("\n", mi
->raw_stdout
);
2081 /* Determine whether the parsed command already notifies the
2082 user_selected_context_changed observer. */
2085 command_notifies_uscc_observer (struct mi_parse
*command
)
2087 if (command
->op
== CLI_COMMAND
)
2089 /* CLI commands "thread" and "inferior" already send it. */
2090 return (strncmp (command
->command
, "thread ", 7) == 0
2091 || strncmp (command
->command
, "inferior ", 9) == 0);
2093 else /* MI_COMMAND */
2095 if (strcmp (command
->command
, "interpreter-exec") == 0
2096 && command
->argc
> 1)
2098 /* "thread" and "inferior" again, but through -interpreter-exec. */
2099 return (strncmp (command
->argv
[1], "thread ", 7) == 0
2100 || strncmp (command
->argv
[1], "inferior ", 9) == 0);
2104 /* -thread-select already sends it. */
2105 return strcmp (command
->command
, "thread-select") == 0;
2110 mi_execute_command (const char *cmd
, int from_tty
)
2113 std::unique_ptr
<struct mi_parse
> command
;
2115 /* This is to handle EOF (^D). We just quit gdb. */
2116 /* FIXME: we should call some API function here. */
2118 quit_force (NULL
, from_tty
);
2120 target_log_command (cmd
);
2124 command
= mi_parse (cmd
, &token
);
2126 CATCH (exception
, RETURN_MASK_ALL
)
2128 mi_print_exception (token
, exception
);
2133 if (command
!= NULL
)
2135 ptid_t previous_ptid
= inferior_ptid
;
2137 gdb::optional
<scoped_restore_tmpl
<int>> restore_suppress
;
2139 if (command
->cmd
!= NULL
&& command
->cmd
->suppress_notification
!= NULL
)
2140 restore_suppress
.emplace (command
->cmd
->suppress_notification
, 1);
2142 command
->token
= token
;
2146 command
->cmd_start
= new mi_timestamp ();
2147 timestamp (command
->cmd_start
);
2152 captured_mi_execute_command (current_uiout
, command
.get ());
2154 CATCH (result
, RETURN_MASK_ALL
)
2156 /* Like in start_event_loop, enable input and force display
2157 of the prompt. Otherwise, any command that calls
2158 async_disable_stdin, and then throws, will leave input
2160 async_enable_stdin ();
2161 current_ui
->prompt_state
= PROMPT_NEEDED
;
2163 /* The command execution failed and error() was called
2165 mi_print_exception (command
->token
, result
);
2166 mi_out_rewind (current_uiout
);
2170 bpstat_do_actions ();
2172 if (/* The notifications are only output when the top-level
2173 interpreter (specified on the command line) is MI. */
2174 interp_ui_out (top_level_interpreter ())->is_mi_like_p ()
2175 /* Don't try report anything if there are no threads --
2176 the program is dead. */
2177 && thread_count () != 0
2178 /* If the command already reports the thread change, no need to do it
2180 && !command_notifies_uscc_observer (command
.get ()))
2182 struct mi_interp
*mi
= (struct mi_interp
*) top_level_interpreter ();
2183 int report_change
= 0;
2185 if (command
->thread
== -1)
2187 report_change
= (!ptid_equal (previous_ptid
, null_ptid
)
2188 && !ptid_equal (inferior_ptid
, previous_ptid
)
2189 && !ptid_equal (inferior_ptid
, null_ptid
));
2191 else if (!ptid_equal (inferior_ptid
, null_ptid
))
2193 struct thread_info
*ti
= inferior_thread ();
2195 report_change
= (ti
->global_num
!= command
->thread
);
2200 observer_notify_user_selected_context_changed
2201 (USER_SELECTED_THREAD
| USER_SELECTED_FRAME
);
2208 mi_cmd_execute (struct mi_parse
*parse
)
2210 struct cleanup
*cleanup
;
2212 cleanup
= prepare_execute_command ();
2214 if (parse
->all
&& parse
->thread_group
!= -1)
2215 error (_("Cannot specify --thread-group together with --all"));
2217 if (parse
->all
&& parse
->thread
!= -1)
2218 error (_("Cannot specify --thread together with --all"));
2220 if (parse
->thread_group
!= -1 && parse
->thread
!= -1)
2221 error (_("Cannot specify --thread together with --thread-group"));
2223 if (parse
->frame
!= -1 && parse
->thread
== -1)
2224 error (_("Cannot specify --frame without --thread"));
2226 if (parse
->thread_group
!= -1)
2228 struct inferior
*inf
= find_inferior_id (parse
->thread_group
);
2229 struct thread_info
*tp
= 0;
2232 error (_("Invalid thread group for the --thread-group option"));
2234 set_current_inferior (inf
);
2235 /* This behaviour means that if --thread-group option identifies
2236 an inferior with multiple threads, then a random one will be
2237 picked. This is not a problem -- frontend should always
2238 provide --thread if it wishes to operate on a specific
2241 tp
= any_live_thread_of_process (inf
->pid
);
2242 switch_to_thread (tp
? tp
->ptid
: null_ptid
);
2243 set_current_program_space (inf
->pspace
);
2246 if (parse
->thread
!= -1)
2248 struct thread_info
*tp
= find_thread_global_id (parse
->thread
);
2251 error (_("Invalid thread id: %d"), parse
->thread
);
2253 if (is_exited (tp
->ptid
))
2254 error (_("Thread id: %d has terminated"), parse
->thread
);
2256 switch_to_thread (tp
->ptid
);
2259 if (parse
->frame
!= -1)
2261 struct frame_info
*fid
;
2262 int frame
= parse
->frame
;
2264 fid
= find_relative_frame (get_current_frame (), &frame
);
2266 /* find_relative_frame was successful */
2269 error (_("Invalid frame id: %d"), frame
);
2272 if (parse
->language
!= language_unknown
)
2274 make_cleanup_restore_current_language ();
2275 set_language (parse
->language
);
2278 current_context
= parse
;
2280 if (parse
->cmd
->argv_func
!= NULL
)
2282 parse
->cmd
->argv_func (parse
->command
, parse
->argv
, parse
->argc
);
2284 else if (parse
->cmd
->cli
.cmd
!= 0)
2286 /* FIXME: DELETE THIS. */
2287 /* The operation is still implemented by a cli command. */
2288 /* Must be a synchronous one. */
2289 mi_execute_cli_command (parse
->cmd
->cli
.cmd
, parse
->cmd
->cli
.args_p
,
2294 /* FIXME: DELETE THIS. */
2297 stb
.puts ("Undefined mi command: ");
2298 stb
.putstr (parse
->command
, '"');
2299 stb
.puts (" (missing implementation)");
2303 do_cleanups (cleanup
);
2306 /* FIXME: This is just a hack so we can get some extra commands going.
2307 We don't want to channel things through the CLI, but call libgdb directly.
2308 Use only for synchronous commands. */
2311 mi_execute_cli_command (const char *cmd
, int args_p
, const char *args
)
2315 struct cleanup
*old_cleanups
;
2319 run
= xstrprintf ("%s %s", cmd
, args
);
2321 run
= xstrdup (cmd
);
2323 /* FIXME: gdb_???? */
2324 fprintf_unfiltered (gdb_stdout
, "cli=%s run=%s\n",
2326 old_cleanups
= make_cleanup (xfree
, run
);
2327 execute_command (run
, 0 /* from_tty */ );
2328 do_cleanups (old_cleanups
);
2334 mi_execute_async_cli_command (const char *cli_command
, char **argv
, int argc
)
2336 struct cleanup
*old_cleanups
;
2340 run
= xstrprintf ("%s %s&", cli_command
, argc
? *argv
: "");
2342 run
= xstrprintf ("%s %s", cli_command
, argc
? *argv
: "");
2343 old_cleanups
= make_cleanup (xfree
, run
);
2345 execute_command (run
, 0 /* from_tty */ );
2347 /* Do this before doing any printing. It would appear that some
2348 print code leaves garbage around in the buffer. */
2349 do_cleanups (old_cleanups
);
2353 mi_load_progress (const char *section_name
,
2354 unsigned long sent_so_far
,
2355 unsigned long total_section
,
2356 unsigned long total_sent
,
2357 unsigned long grand_total
)
2359 using namespace std::chrono
;
2360 static steady_clock::time_point last_update
;
2361 static char *previous_sect_name
= NULL
;
2363 struct ui_out
*saved_uiout
;
2364 struct ui_out
*uiout
;
2365 struct mi_interp
*mi
= (struct mi_interp
*) current_interpreter ();
2367 /* This function is called through deprecated_show_load_progress
2368 which means uiout may not be correct. Fix it for the duration
2369 of this function. */
2370 saved_uiout
= current_uiout
;
2372 if (current_interp_named_p (INTERP_MI
)
2373 || current_interp_named_p (INTERP_MI2
))
2374 current_uiout
= mi_out_new (2);
2375 else if (current_interp_named_p (INTERP_MI1
))
2376 current_uiout
= mi_out_new (1);
2377 else if (current_interp_named_p (INTERP_MI3
))
2378 current_uiout
= mi_out_new (3);
2382 uiout
= current_uiout
;
2384 new_section
= (previous_sect_name
?
2385 strcmp (previous_sect_name
, section_name
) : 1);
2388 struct cleanup
*cleanup_tuple
;
2390 xfree (previous_sect_name
);
2391 previous_sect_name
= xstrdup (section_name
);
2394 fputs_unfiltered (current_token
, mi
->raw_stdout
);
2395 fputs_unfiltered ("+download", mi
->raw_stdout
);
2396 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2397 uiout
->field_string ("section", section_name
);
2398 uiout
->field_int ("section-size", total_section
);
2399 uiout
->field_int ("total-size", grand_total
);
2400 do_cleanups (cleanup_tuple
);
2401 mi_out_put (uiout
, mi
->raw_stdout
);
2402 fputs_unfiltered ("\n", mi
->raw_stdout
);
2403 gdb_flush (mi
->raw_stdout
);
2406 steady_clock::time_point time_now
= steady_clock::now ();
2407 if (time_now
- last_update
> milliseconds (500))
2409 struct cleanup
*cleanup_tuple
;
2411 last_update
= time_now
;
2413 fputs_unfiltered (current_token
, mi
->raw_stdout
);
2414 fputs_unfiltered ("+download", mi
->raw_stdout
);
2415 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2416 uiout
->field_string ("section", section_name
);
2417 uiout
->field_int ("section-sent", sent_so_far
);
2418 uiout
->field_int ("section-size", total_section
);
2419 uiout
->field_int ("total-sent", total_sent
);
2420 uiout
->field_int ("total-size", grand_total
);
2421 do_cleanups (cleanup_tuple
);
2422 mi_out_put (uiout
, mi
->raw_stdout
);
2423 fputs_unfiltered ("\n", mi
->raw_stdout
);
2424 gdb_flush (mi
->raw_stdout
);
2428 current_uiout
= saved_uiout
;
2432 timestamp (struct mi_timestamp
*tv
)
2434 using namespace std::chrono
;
2436 tv
->wallclock
= steady_clock::now ();
2437 run_time_clock::now (tv
->utime
, tv
->stime
);
2441 print_diff_now (struct ui_file
*file
, struct mi_timestamp
*start
)
2443 struct mi_timestamp now
;
2446 print_diff (file
, start
, &now
);
2450 mi_print_timing_maybe (struct ui_file
*file
)
2452 /* If the command is -enable-timing then do_timings may be true
2453 whilst current_command_ts is not initialized. */
2454 if (do_timings
&& current_command_ts
)
2455 print_diff_now (file
, current_command_ts
);
2459 print_diff (struct ui_file
*file
, struct mi_timestamp
*start
,
2460 struct mi_timestamp
*end
)
2462 using namespace std::chrono
;
2464 duration
<double> wallclock
= end
->wallclock
- start
->wallclock
;
2465 duration
<double> utime
= end
->utime
- start
->utime
;
2466 duration
<double> stime
= end
->stime
- start
->stime
;
2470 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
2471 wallclock
.count (), utime
.count (), stime
.count ());
2475 mi_cmd_trace_define_variable (const char *command
, char **argv
, int argc
)
2477 LONGEST initval
= 0;
2478 struct trace_state_variable
*tsv
;
2481 if (argc
!= 1 && argc
!= 2)
2482 error (_("Usage: -trace-define-variable VARIABLE [VALUE]"));
2486 error (_("Name of trace variable should start with '$'"));
2488 validate_trace_state_variable_name (name
);
2490 tsv
= find_trace_state_variable (name
);
2492 tsv
= create_trace_state_variable (name
);
2495 initval
= value_as_long (parse_and_eval (argv
[1]));
2497 tsv
->initial_value
= initval
;
2501 mi_cmd_trace_list_variables (const char *command
, char **argv
, int argc
)
2504 error (_("-trace-list-variables: no arguments allowed"));
2506 tvariables_info_1 ();
2510 mi_cmd_trace_find (const char *command
, char **argv
, int argc
)
2515 error (_("trace selection mode is required"));
2519 if (strcmp (mode
, "none") == 0)
2521 tfind_1 (tfind_number
, -1, 0, 0, 0);
2525 check_trace_running (current_trace_status ());
2527 if (strcmp (mode
, "frame-number") == 0)
2530 error (_("frame number is required"));
2531 tfind_1 (tfind_number
, atoi (argv
[1]), 0, 0, 0);
2533 else if (strcmp (mode
, "tracepoint-number") == 0)
2536 error (_("tracepoint number is required"));
2537 tfind_1 (tfind_tp
, atoi (argv
[1]), 0, 0, 0);
2539 else if (strcmp (mode
, "pc") == 0)
2542 error (_("PC is required"));
2543 tfind_1 (tfind_pc
, 0, parse_and_eval_address (argv
[1]), 0, 0);
2545 else if (strcmp (mode
, "pc-inside-range") == 0)
2548 error (_("Start and end PC are required"));
2549 tfind_1 (tfind_range
, 0, parse_and_eval_address (argv
[1]),
2550 parse_and_eval_address (argv
[2]), 0);
2552 else if (strcmp (mode
, "pc-outside-range") == 0)
2555 error (_("Start and end PC are required"));
2556 tfind_1 (tfind_outside
, 0, parse_and_eval_address (argv
[1]),
2557 parse_and_eval_address (argv
[2]), 0);
2559 else if (strcmp (mode
, "line") == 0)
2561 struct symtabs_and_lines sals
;
2562 struct symtab_and_line sal
;
2563 static CORE_ADDR start_pc
, end_pc
;
2564 struct cleanup
*back_to
;
2567 error (_("Line is required"));
2569 sals
= decode_line_with_current_source (argv
[1],
2570 DECODE_LINE_FUNFIRSTLINE
);
2571 back_to
= make_cleanup (xfree
, sals
.sals
);
2575 if (sal
.symtab
== 0)
2576 error (_("Could not find the specified line"));
2578 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2579 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, 0);
2581 error (_("Could not find the specified line"));
2583 do_cleanups (back_to
);
2586 error (_("Invalid mode '%s'"), mode
);
2588 if (has_stack_frames () || get_traceframe_number () >= 0)
2589 print_stack_frame (get_selected_frame (NULL
), 1, LOC_AND_ADDRESS
, 1);
2593 mi_cmd_trace_save (const char *command
, char **argv
, int argc
)
2595 int target_saves
= 0;
2596 int generate_ctf
= 0;
2603 TARGET_SAVE_OPT
, CTF_OPT
2605 static const struct mi_opt opts
[] =
2607 {"r", TARGET_SAVE_OPT
, 0},
2608 {"ctf", CTF_OPT
, 0},
2614 int opt
= mi_getopt ("-trace-save", argc
, argv
, opts
,
2619 switch ((enum opt
) opt
)
2621 case TARGET_SAVE_OPT
:
2630 if (argc
- oind
!= 1)
2631 error (_("Exactly one argument required "
2632 "(file in which to save trace data)"));
2634 filename
= argv
[oind
];
2637 trace_save_ctf (filename
, target_saves
);
2639 trace_save_tfile (filename
, target_saves
);
2643 mi_cmd_trace_start (const char *command
, char **argv
, int argc
)
2645 start_tracing (NULL
);
2649 mi_cmd_trace_status (const char *command
, char **argv
, int argc
)
2651 trace_status_mi (0);
2655 mi_cmd_trace_stop (const char *command
, char **argv
, int argc
)
2657 stop_tracing (NULL
);
2658 trace_status_mi (1);
2661 /* Implement the "-ada-task-info" command. */
2664 mi_cmd_ada_task_info (const char *command
, char **argv
, int argc
)
2666 if (argc
!= 0 && argc
!= 1)
2667 error (_("Invalid MI command"));
2669 print_ada_task_info (current_uiout
, argv
[0], current_inferior ());
2672 /* Print EXPRESSION according to VALUES. */
2675 print_variable_or_computed (const char *expression
, enum print_values values
)
2677 struct cleanup
*old_chain
;
2680 struct ui_out
*uiout
= current_uiout
;
2684 expression_up expr
= parse_expression (expression
);
2686 if (values
== PRINT_SIMPLE_VALUES
)
2687 val
= evaluate_type (expr
.get ());
2689 val
= evaluate_expression (expr
.get ());
2691 old_chain
= make_cleanup (null_cleanup
, NULL
);
2692 if (values
!= PRINT_NO_VALUES
)
2693 make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2694 uiout
->field_string ("name", expression
);
2698 case PRINT_SIMPLE_VALUES
:
2699 type
= check_typedef (value_type (val
));
2700 type_print (value_type (val
), "", &stb
, -1);
2701 uiout
->field_stream ("type", stb
);
2702 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
2703 && TYPE_CODE (type
) != TYPE_CODE_STRUCT
2704 && TYPE_CODE (type
) != TYPE_CODE_UNION
)
2706 struct value_print_options opts
;
2708 get_no_prettyformat_print_options (&opts
);
2710 common_val_print (val
, &stb
, 0, &opts
, current_language
);
2711 uiout
->field_stream ("value", stb
);
2714 case PRINT_ALL_VALUES
:
2716 struct value_print_options opts
;
2718 get_no_prettyformat_print_options (&opts
);
2720 common_val_print (val
, &stb
, 0, &opts
, current_language
);
2721 uiout
->field_stream ("value", stb
);
2726 do_cleanups (old_chain
);
2729 /* Implement the "-trace-frame-collected" command. */
2732 mi_cmd_trace_frame_collected (const char *command
, char **argv
, int argc
)
2734 struct cleanup
*old_chain
;
2735 struct bp_location
*tloc
;
2737 struct collection_list
*clist
;
2738 struct collection_list tracepoint_list
, stepping_list
;
2739 struct traceframe_info
*tinfo
;
2741 enum print_values var_print_values
= PRINT_ALL_VALUES
;
2742 enum print_values comp_print_values
= PRINT_ALL_VALUES
;
2743 int registers_format
= 'x';
2744 int memory_contents
= 0;
2745 struct ui_out
*uiout
= current_uiout
;
2753 static const struct mi_opt opts
[] =
2755 {"-var-print-values", VAR_PRINT_VALUES
, 1},
2756 {"-comp-print-values", COMP_PRINT_VALUES
, 1},
2757 {"-registers-format", REGISTERS_FORMAT
, 1},
2758 {"-memory-contents", MEMORY_CONTENTS
, 0},
2765 int opt
= mi_getopt ("-trace-frame-collected", argc
, argv
, opts
,
2769 switch ((enum opt
) opt
)
2771 case VAR_PRINT_VALUES
:
2772 var_print_values
= mi_parse_print_values (oarg
);
2774 case COMP_PRINT_VALUES
:
2775 comp_print_values
= mi_parse_print_values (oarg
);
2777 case REGISTERS_FORMAT
:
2778 registers_format
= oarg
[0];
2779 case MEMORY_CONTENTS
:
2780 memory_contents
= 1;
2786 error (_("Usage: -trace-frame-collected "
2787 "[--var-print-values PRINT_VALUES] "
2788 "[--comp-print-values PRINT_VALUES] "
2789 "[--registers-format FORMAT]"
2790 "[--memory-contents]"));
2792 /* This throws an error is not inspecting a trace frame. */
2793 tloc
= get_traceframe_location (&stepping_frame
);
2795 /* This command only makes sense for the current frame, not the
2797 old_chain
= make_cleanup_restore_current_thread ();
2798 select_frame (get_current_frame ());
2800 encode_actions (tloc
, &tracepoint_list
, &stepping_list
);
2803 clist
= &stepping_list
;
2805 clist
= &tracepoint_list
;
2807 tinfo
= get_traceframe_info ();
2809 /* Explicitly wholly collected variables. */
2811 struct cleanup
*list_cleanup
;
2814 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
,
2815 "explicit-variables");
2817 const std::vector
<std::string
> &wholly_collected
2818 = clist
->wholly_collected ();
2819 for (size_t i
= 0; i
< wholly_collected
.size (); i
++)
2821 const std::string
&str
= wholly_collected
[i
];
2822 print_variable_or_computed (str
.c_str (), var_print_values
);
2825 do_cleanups (list_cleanup
);
2828 /* Computed expressions. */
2830 struct cleanup
*list_cleanup
;
2835 = make_cleanup_ui_out_list_begin_end (uiout
,
2836 "computed-expressions");
2838 const std::vector
<std::string
> &computed
= clist
->computed ();
2839 for (size_t i
= 0; i
< computed
.size (); i
++)
2841 const std::string
&str
= computed
[i
];
2842 print_variable_or_computed (str
.c_str (), comp_print_values
);
2845 do_cleanups (list_cleanup
);
2848 /* Registers. Given pseudo-registers, and that some architectures
2849 (like MIPS) actually hide the raw registers, we don't go through
2850 the trace frame info, but instead consult the register cache for
2851 register availability. */
2853 struct cleanup
*list_cleanup
;
2854 struct frame_info
*frame
;
2855 struct gdbarch
*gdbarch
;
2859 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "registers");
2861 frame
= get_selected_frame (NULL
);
2862 gdbarch
= get_frame_arch (frame
);
2863 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
2865 for (regnum
= 0; regnum
< numregs
; regnum
++)
2867 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
2868 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
2871 output_register (frame
, regnum
, registers_format
, 1);
2874 do_cleanups (list_cleanup
);
2877 /* Trace state variables. */
2879 struct cleanup
*list_cleanup
;
2884 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "tvars");
2887 make_cleanup (free_current_contents
, &tsvname
);
2889 for (i
= 0; VEC_iterate (int, tinfo
->tvars
, i
, tvar
); i
++)
2891 struct cleanup
*cleanup_child
;
2892 struct trace_state_variable
*tsv
;
2894 tsv
= find_trace_state_variable_by_number (tvar
);
2896 cleanup_child
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2900 tsvname
= (char *) xrealloc (tsvname
, strlen (tsv
->name
) + 2);
2902 strcpy (tsvname
+ 1, tsv
->name
);
2903 uiout
->field_string ("name", tsvname
);
2905 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
2907 uiout
->field_int ("current", tsv
->value
);
2911 uiout
->field_skip ("name");
2912 uiout
->field_skip ("current");
2915 do_cleanups (cleanup_child
);
2918 do_cleanups (list_cleanup
);
2923 struct cleanup
*list_cleanup
;
2924 VEC(mem_range_s
) *available_memory
= NULL
;
2925 struct mem_range
*r
;
2928 traceframe_available_memory (&available_memory
, 0, ULONGEST_MAX
);
2929 make_cleanup (VEC_cleanup(mem_range_s
), &available_memory
);
2931 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "memory");
2933 for (i
= 0; VEC_iterate (mem_range_s
, available_memory
, i
, r
); i
++)
2935 struct cleanup
*cleanup_child
;
2937 struct gdbarch
*gdbarch
= target_gdbarch ();
2939 cleanup_child
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2941 uiout
->field_core_addr ("address", gdbarch
, r
->start
);
2942 uiout
->field_int ("length", r
->length
);
2944 data
= (gdb_byte
*) xmalloc (r
->length
);
2945 make_cleanup (xfree
, data
);
2947 if (memory_contents
)
2949 if (target_read_memory (r
->start
, data
, r
->length
) == 0)
2954 data_str
= (char *) xmalloc (r
->length
* 2 + 1);
2955 make_cleanup (xfree
, data_str
);
2957 for (m
= 0, p
= data_str
; m
< r
->length
; ++m
, p
+= 2)
2958 sprintf (p
, "%02x", data
[m
]);
2959 uiout
->field_string ("contents", data_str
);
2962 uiout
->field_skip ("contents");
2964 do_cleanups (cleanup_child
);
2967 do_cleanups (list_cleanup
);
2970 do_cleanups (old_chain
);
2974 _initialize_mi_main (void)
2976 struct cmd_list_element
*c
;
2978 add_setshow_boolean_cmd ("mi-async", class_run
,
2980 Set whether MI asynchronous mode is enabled."), _("\
2981 Show whether MI asynchronous mode is enabled."), _("\
2982 Tells GDB whether MI should be in asynchronous mode."),
2983 set_mi_async_command
,
2984 show_mi_async_command
,
2988 /* Alias old "target-async" to "mi-async". */
2989 c
= add_alias_cmd ("target-async", "mi-async", class_run
, 0, &setlist
);
2990 deprecate_cmd (c
, "set mi-async");
2991 c
= add_alias_cmd ("target-async", "mi-async", class_run
, 0, &showlist
);
2992 deprecate_cmd (c
, "show mi-async");