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"
58 #include "common/byte-vector.h"
61 #include "run-time-clock.h"
63 #include "progspace-and-thread.h"
72 /* This is used to pass the current command timestamp down to
73 continuation routines. */
74 static struct mi_timestamp
*current_command_ts
;
76 static int do_timings
= 0;
79 /* Few commands would like to know if options like --thread-group were
80 explicitly specified. This variable keeps the current parsed
81 command including all option, and make it possible. */
82 static struct mi_parse
*current_context
;
84 int running_result_record_printed
= 1;
86 /* Flag indicating that the target has proceeded since the last
87 command was issued. */
90 extern void _initialize_mi_main (void);
91 static void mi_cmd_execute (struct mi_parse
*parse
);
93 static void mi_execute_cli_command (const char *cmd
, int args_p
,
95 static void mi_execute_async_cli_command (const char *cli_command
,
96 char **argv
, int argc
);
97 static int register_changed_p (int regnum
, struct regcache
*,
99 static void output_register (struct frame_info
*, int regnum
, int format
,
100 int skip_unavailable
);
102 /* Controls whether the frontend wants MI in async mode. */
103 static int mi_async
= 0;
105 /* The set command writes to this variable. If the inferior is
106 executing, mi_async is *not* updated. */
107 static int mi_async_1
= 0;
110 set_mi_async_command (char *args
, int from_tty
,
111 struct cmd_list_element
*c
)
113 if (have_live_inferiors ())
115 mi_async_1
= mi_async
;
116 error (_("Cannot change this setting while the inferior is running."));
119 mi_async
= mi_async_1
;
123 show_mi_async_command (struct ui_file
*file
, int from_tty
,
124 struct cmd_list_element
*c
,
127 fprintf_filtered (file
,
128 _("Whether MI is in asynchronous mode is %s.\n"),
132 /* A wrapper for target_can_async_p that takes the MI setting into
138 return mi_async
&& target_can_async_p ();
141 /* Command implementations. FIXME: Is this libgdb? No. This is the MI
142 layer that calls libgdb. Any operation used in the below should be
145 static void timestamp (struct mi_timestamp
*tv
);
147 static void print_diff (struct ui_file
*file
, struct mi_timestamp
*start
,
148 struct mi_timestamp
*end
);
151 mi_cmd_gdb_exit (const char *command
, char **argv
, int argc
)
153 struct mi_interp
*mi
= (struct mi_interp
*) current_interpreter ();
155 /* We have to print everything right here because we never return. */
157 fputs_unfiltered (current_token
, mi
->raw_stdout
);
158 fputs_unfiltered ("^exit\n", mi
->raw_stdout
);
159 mi_out_put (current_uiout
, mi
->raw_stdout
);
160 gdb_flush (mi
->raw_stdout
);
161 /* FIXME: The function called is not yet a formal libgdb function. */
162 quit_force (NULL
, FROM_TTY
);
166 mi_cmd_exec_next (const char *command
, char **argv
, int argc
)
168 /* FIXME: Should call a libgdb function, not a cli wrapper. */
169 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
170 mi_execute_async_cli_command ("reverse-next", argv
+ 1, argc
- 1);
172 mi_execute_async_cli_command ("next", argv
, argc
);
176 mi_cmd_exec_next_instruction (const char *command
, char **argv
, int argc
)
178 /* FIXME: Should call a libgdb function, not a cli wrapper. */
179 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
180 mi_execute_async_cli_command ("reverse-nexti", argv
+ 1, argc
- 1);
182 mi_execute_async_cli_command ("nexti", argv
, argc
);
186 mi_cmd_exec_step (const char *command
, char **argv
, int argc
)
188 /* FIXME: Should call a libgdb function, not a cli wrapper. */
189 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
190 mi_execute_async_cli_command ("reverse-step", argv
+ 1, argc
- 1);
192 mi_execute_async_cli_command ("step", argv
, argc
);
196 mi_cmd_exec_step_instruction (const char *command
, char **argv
, int argc
)
198 /* FIXME: Should call a libgdb function, not a cli wrapper. */
199 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
200 mi_execute_async_cli_command ("reverse-stepi", argv
+ 1, argc
- 1);
202 mi_execute_async_cli_command ("stepi", argv
, argc
);
206 mi_cmd_exec_finish (const char *command
, char **argv
, int argc
)
208 /* FIXME: Should call a libgdb function, not a cli wrapper. */
209 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
210 mi_execute_async_cli_command ("reverse-finish", argv
+ 1, argc
- 1);
212 mi_execute_async_cli_command ("finish", argv
, argc
);
216 mi_cmd_exec_return (const char *command
, char **argv
, int argc
)
218 /* This command doesn't really execute the target, it just pops the
219 specified number of frames. */
221 /* Call return_command with from_tty argument equal to 0 so as to
222 avoid being queried. */
223 return_command (*argv
, 0);
225 /* Call return_command with from_tty argument equal to 0 so as to
226 avoid being queried. */
227 return_command (NULL
, 0);
229 /* Because we have called return_command with from_tty = 0, we need
230 to print the frame here. */
231 print_stack_frame (get_selected_frame (NULL
), 1, LOC_AND_ADDRESS
, 1);
235 mi_cmd_exec_jump (const char *args
, char **argv
, int argc
)
237 /* FIXME: Should call a libgdb function, not a cli wrapper. */
238 mi_execute_async_cli_command ("jump", argv
, argc
);
242 proceed_thread (struct thread_info
*thread
, int pid
)
244 if (!is_stopped (thread
->ptid
))
247 if (pid
!= 0 && ptid_get_pid (thread
->ptid
) != pid
)
250 switch_to_thread (thread
->ptid
);
251 clear_proceed_status (0);
252 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
);
256 proceed_thread_callback (struct thread_info
*thread
, void *arg
)
258 int pid
= *(int *)arg
;
260 proceed_thread (thread
, pid
);
265 exec_continue (char **argv
, int argc
)
267 prepare_execution_command (¤t_target
, mi_async_p ());
271 /* In non-stop mode, 'resume' always resumes a single thread.
272 Therefore, to resume all threads of the current inferior, or
273 all threads in all inferiors, we need to iterate over
276 See comment on infcmd.c:proceed_thread_callback for rationale. */
277 if (current_context
->all
|| current_context
->thread_group
!= -1)
279 scoped_restore_current_thread restore_thread
;
282 if (!current_context
->all
)
285 = find_inferior_id (current_context
->thread_group
);
289 iterate_over_threads (proceed_thread_callback
, &pid
);
298 scoped_restore save_multi
= make_scoped_restore (&sched_multi
);
300 if (current_context
->all
)
307 /* In all-stop mode, -exec-continue traditionally resumed
308 either all threads, or one thread, depending on the
309 'scheduler-locking' variable. Let's continue to do the
317 exec_reverse_continue (char **argv
, int argc
)
319 enum exec_direction_kind dir
= execution_direction
;
321 if (dir
== EXEC_REVERSE
)
322 error (_("Already in reverse mode."));
324 if (!target_can_execute_reverse
)
325 error (_("Target %s does not support this command."), target_shortname
);
327 scoped_restore save_exec_dir
= make_scoped_restore (&execution_direction
,
329 exec_continue (argv
, argc
);
333 mi_cmd_exec_continue (const char *command
, char **argv
, int argc
)
335 if (argc
> 0 && strcmp (argv
[0], "--reverse") == 0)
336 exec_reverse_continue (argv
+ 1, argc
- 1);
338 exec_continue (argv
, argc
);
342 interrupt_thread_callback (struct thread_info
*thread
, void *arg
)
344 int pid
= *(int *)arg
;
346 if (!is_running (thread
->ptid
))
349 if (ptid_get_pid (thread
->ptid
) != pid
)
352 target_stop (thread
->ptid
);
356 /* Interrupt the execution of the target. Note how we must play
357 around with the token variables, in order to display the current
358 token in the result of the interrupt command, and the previous
359 execution token when the target finally stops. See comments in
363 mi_cmd_exec_interrupt (const char *command
, char **argv
, int argc
)
365 /* In all-stop mode, everything stops, so we don't need to try
366 anything specific. */
369 interrupt_target_1 (0);
373 if (current_context
->all
)
375 /* This will interrupt all threads in all inferiors. */
376 interrupt_target_1 (1);
378 else if (current_context
->thread_group
!= -1)
380 struct inferior
*inf
= find_inferior_id (current_context
->thread_group
);
382 iterate_over_threads (interrupt_thread_callback
, &inf
->pid
);
386 /* Interrupt just the current thread -- either explicitly
387 specified via --thread or whatever was current before
388 MI command was sent. */
389 interrupt_target_1 (0);
393 /* Callback for iterate_over_inferiors which starts the execution
394 of the given inferior.
396 ARG is a pointer to an integer whose value, if non-zero, indicates
397 that the program should be stopped when reaching the main subprogram
398 (similar to what the CLI "start" command does). */
401 run_one_inferior (struct inferior
*inf
, void *arg
)
403 int start_p
= *(int *) arg
;
404 const char *run_cmd
= start_p
? "start" : "run";
405 struct target_ops
*run_target
= find_run_target ();
406 int async_p
= mi_async
&& run_target
->to_can_async_p (run_target
);
410 if (inf
->pid
!= ptid_get_pid (inferior_ptid
))
412 struct thread_info
*tp
;
414 tp
= any_thread_of_process (inf
->pid
);
416 error (_("Inferior has no threads."));
418 switch_to_thread (tp
->ptid
);
423 set_current_inferior (inf
);
424 switch_to_thread (null_ptid
);
425 set_current_program_space (inf
->pspace
);
427 mi_execute_cli_command (run_cmd
, async_p
,
428 async_p
? "&" : NULL
);
433 mi_cmd_exec_run (const char *command
, char **argv
, int argc
)
437 /* Parse the command options. */
442 static const struct mi_opt opts
[] =
444 {"-start", START_OPT
, 0},
453 int opt
= mi_getopt ("-exec-run", argc
, argv
, opts
, &oind
, &oarg
);
457 switch ((enum opt
) opt
)
465 /* This command does not accept any argument. Make sure the user
466 did not provide any. */
468 error (_("Invalid argument: %s"), argv
[oind
]);
470 if (current_context
->all
)
472 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
474 iterate_over_inferiors (run_one_inferior
, &start_p
);
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 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
665 uiout
->field_fmt ("id", "i%d", inferior
->num
);
666 uiout
->field_string ("type", "process");
667 if (inferior
->has_exit_code
)
668 uiout
->field_string ("exit-code",
669 int_string (inferior
->exit_code
, 8, 0, 0, 1));
670 if (inferior
->pid
!= 0)
671 uiout
->field_int ("pid", inferior
->pid
);
673 if (inferior
->pspace
->pspace_exec_filename
!= NULL
)
675 uiout
->field_string ("executable",
676 inferior
->pspace
->pspace_exec_filename
);
680 if (inferior
->pid
!= 0)
682 data
.pid
= inferior
->pid
;
683 iterate_over_threads (collect_cores
, &data
);
686 if (!VEC_empty (int, data
.cores
))
689 ui_out_emit_list
list_emitter (uiout
, "cores");
691 qsort (VEC_address (int, data
.cores
),
692 VEC_length (int, data
.cores
), sizeof (int),
693 compare_positive_ints
);
695 b
= VEC_address (int, data
.cores
);
696 e
= b
+ VEC_length (int, data
.cores
);
700 uiout
->field_int (NULL
, *b
);
703 if (top_data
->recurse
)
704 print_thread_info (uiout
, NULL
, inferior
->pid
);
710 /* Output a field named 'cores' with a list as the value. The
711 elements of the list are obtained by splitting 'cores' on
715 output_cores (struct ui_out
*uiout
, const char *field_name
, const char *xcores
)
717 struct cleanup
*back_to
= make_cleanup_ui_out_list_begin_end (uiout
,
719 char *cores
= xstrdup (xcores
);
722 make_cleanup (xfree
, cores
);
724 for (p
= strtok (p
, ","); p
; p
= strtok (NULL
, ","))
725 uiout
->field_string (NULL
, p
);
727 do_cleanups (back_to
);
731 free_vector_of_ints (void *xvector
)
733 VEC (int) **vector
= (VEC (int) **) xvector
;
735 VEC_free (int, *vector
);
739 do_nothing (splay_tree_key k
)
744 free_vector_of_osdata_items (splay_tree_value xvalue
)
746 VEC (osdata_item_s
) *value
= (VEC (osdata_item_s
) *) xvalue
;
748 /* We don't free the items itself, it will be done separately. */
749 VEC_free (osdata_item_s
, value
);
753 splay_tree_int_comparator (splay_tree_key xa
, splay_tree_key xb
)
762 free_splay_tree (void *xt
)
764 splay_tree t
= (splay_tree
) xt
;
765 splay_tree_delete (t
);
769 list_available_thread_groups (VEC (int) *ids
, int recurse
)
772 struct osdata_item
*item
;
774 struct ui_out
*uiout
= current_uiout
;
775 struct cleanup
*cleanup
;
777 /* This keeps a map from integer (pid) to VEC (struct osdata_item *)*
778 The vector contains information about all threads for the given pid.
779 This is assigned an initial value to avoid "may be used uninitialized"
781 splay_tree tree
= NULL
;
783 /* get_osdata will throw if it cannot return data. */
784 data
= get_osdata ("processes");
785 cleanup
= make_cleanup_osdata_free (data
);
789 struct osdata
*threads
= get_osdata ("threads");
791 make_cleanup_osdata_free (threads
);
792 tree
= splay_tree_new (splay_tree_int_comparator
,
794 free_vector_of_osdata_items
);
795 make_cleanup (free_splay_tree
, tree
);
798 VEC_iterate (osdata_item_s
, threads
->items
,
802 const char *pid
= get_osdata_column (item
, "pid");
803 int pid_i
= strtoul (pid
, NULL
, 0);
804 VEC (osdata_item_s
) *vec
= 0;
806 splay_tree_node n
= splay_tree_lookup (tree
, pid_i
);
809 VEC_safe_push (osdata_item_s
, vec
, item
);
810 splay_tree_insert (tree
, pid_i
, (splay_tree_value
)vec
);
814 vec
= (VEC (osdata_item_s
) *) n
->value
;
815 VEC_safe_push (osdata_item_s
, vec
, item
);
816 n
->value
= (splay_tree_value
) vec
;
821 make_cleanup_ui_out_list_begin_end (uiout
, "groups");
824 VEC_iterate (osdata_item_s
, data
->items
,
828 const char *pid
= get_osdata_column (item
, "pid");
829 const char *cmd
= get_osdata_column (item
, "command");
830 const char *user
= get_osdata_column (item
, "user");
831 const char *cores
= get_osdata_column (item
, "cores");
833 int pid_i
= strtoul (pid
, NULL
, 0);
835 /* At present, the target will return all available processes
836 and if information about specific ones was required, we filter
837 undesired processes here. */
838 if (ids
&& bsearch (&pid_i
, VEC_address (int, ids
),
839 VEC_length (int, ids
),
840 sizeof (int), compare_positive_ints
) == NULL
)
844 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
846 uiout
->field_fmt ("id", "%s", pid
);
847 uiout
->field_string ("type", "process");
849 uiout
->field_string ("description", cmd
);
851 uiout
->field_string ("user", user
);
853 output_cores (uiout
, "cores", cores
);
857 splay_tree_node n
= splay_tree_lookup (tree
, pid_i
);
860 VEC (osdata_item_s
) *children
= (VEC (osdata_item_s
) *) n
->value
;
861 struct osdata_item
*child
;
864 make_cleanup_ui_out_list_begin_end (uiout
, "threads");
867 VEC_iterate (osdata_item_s
, children
, ix_child
, child
);
870 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
871 const char *tid
= get_osdata_column (child
, "tid");
872 const char *tcore
= get_osdata_column (child
, "core");
874 uiout
->field_string ("id", tid
);
876 uiout
->field_string ("core", tcore
);
882 do_cleanups (cleanup
);
886 mi_cmd_list_thread_groups (const char *command
, char **argv
, int argc
)
888 struct ui_out
*uiout
= current_uiout
;
889 struct cleanup
*back_to
;
896 AVAILABLE_OPT
, RECURSE_OPT
898 static const struct mi_opt opts
[] =
900 {"-available", AVAILABLE_OPT
, 0},
901 {"-recurse", RECURSE_OPT
, 1},
910 int opt
= mi_getopt ("-list-thread-groups", argc
, argv
, opts
,
915 switch ((enum opt
) opt
)
921 if (strcmp (oarg
, "0") == 0)
923 else if (strcmp (oarg
, "1") == 0)
926 error (_("only '0' and '1' are valid values "
927 "for the '--recurse' option"));
932 for (; oind
< argc
; ++oind
)
937 if (*(argv
[oind
]) != 'i')
938 error (_("invalid syntax of group id '%s'"), argv
[oind
]);
940 inf
= strtoul (argv
[oind
] + 1, &end
, 0);
943 error (_("invalid syntax of group id '%s'"), argv
[oind
]);
944 VEC_safe_push (int, ids
, inf
);
946 if (VEC_length (int, ids
) > 1)
947 qsort (VEC_address (int, ids
),
948 VEC_length (int, ids
),
949 sizeof (int), compare_positive_ints
);
951 back_to
= make_cleanup (free_vector_of_ints
, &ids
);
955 list_available_thread_groups (ids
, recurse
);
957 else if (VEC_length (int, ids
) == 1)
959 /* Local thread groups, single id. */
960 int id
= *VEC_address (int, ids
);
961 struct inferior
*inf
= find_inferior_id (id
);
964 error (_("Non-existent thread group id '%d'"), id
);
966 print_thread_info (uiout
, NULL
, inf
->pid
);
970 struct print_one_inferior_data data
;
972 data
.recurse
= recurse
;
973 data
.inferiors
= ids
;
975 /* Local thread groups. Either no explicit ids -- and we
976 print everything, or several explicit ids. In both cases,
977 we print more than one group, and have to use 'groups'
978 as the top-level element. */
979 make_cleanup_ui_out_list_begin_end (uiout
, "groups");
980 update_thread_list ();
981 iterate_over_inferiors (print_one_inferior
, &data
);
984 do_cleanups (back_to
);
988 mi_cmd_data_list_register_names (const char *command
, char **argv
, int argc
)
990 struct gdbarch
*gdbarch
;
991 struct ui_out
*uiout
= current_uiout
;
995 /* Note that the test for a valid register must include checking the
996 gdbarch_register_name because gdbarch_num_regs may be allocated
997 for the union of the register sets within a family of related
998 processors. In this case, some entries of gdbarch_register_name
999 will change depending upon the particular processor being
1002 gdbarch
= get_current_arch ();
1003 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1005 ui_out_emit_list
list_emitter (uiout
, "register-names");
1007 if (argc
== 0) /* No args, just do all the regs. */
1013 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1014 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1015 uiout
->field_string (NULL
, "");
1017 uiout
->field_string (NULL
, gdbarch_register_name (gdbarch
, regnum
));
1021 /* Else, list of register #s, just do listed regs. */
1022 for (i
= 0; i
< argc
; i
++)
1024 regnum
= atoi (argv
[i
]);
1025 if (regnum
< 0 || regnum
>= numregs
)
1026 error (_("bad register number"));
1028 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1029 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1030 uiout
->field_string (NULL
, "");
1032 uiout
->field_string (NULL
, gdbarch_register_name (gdbarch
, regnum
));
1037 mi_cmd_data_list_changed_registers (const char *command
, char **argv
, int argc
)
1039 static struct regcache
*this_regs
= NULL
;
1040 struct ui_out
*uiout
= current_uiout
;
1041 struct regcache
*prev_regs
;
1042 struct gdbarch
*gdbarch
;
1043 int regnum
, numregs
, changed
;
1045 struct cleanup
*cleanup
;
1047 /* The last time we visited this function, the current frame's
1048 register contents were saved in THIS_REGS. Move THIS_REGS over
1049 to PREV_REGS, and refresh THIS_REGS with the now-current register
1052 prev_regs
= this_regs
;
1053 this_regs
= frame_save_as_regcache (get_selected_frame (NULL
));
1054 cleanup
= make_cleanup_regcache_xfree (prev_regs
);
1056 /* Note that the test for a valid register must include checking the
1057 gdbarch_register_name because gdbarch_num_regs may be allocated
1058 for the union of the register sets within a family of related
1059 processors. In this case, some entries of gdbarch_register_name
1060 will change depending upon the particular processor being
1063 gdbarch
= get_regcache_arch (this_regs
);
1064 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1066 make_cleanup_ui_out_list_begin_end (uiout
, "changed-registers");
1070 /* No args, just do all the regs. */
1075 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1076 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1078 changed
= register_changed_p (regnum
, prev_regs
, this_regs
);
1080 error (_("-data-list-changed-registers: "
1081 "Unable to read register contents."));
1083 uiout
->field_int (NULL
, regnum
);
1087 /* Else, list of register #s, just do listed regs. */
1088 for (i
= 0; i
< argc
; i
++)
1090 regnum
= atoi (argv
[i
]);
1094 && gdbarch_register_name (gdbarch
, regnum
) != NULL
1095 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
1097 changed
= register_changed_p (regnum
, prev_regs
, this_regs
);
1099 error (_("-data-list-changed-registers: "
1100 "Unable to read register contents."));
1102 uiout
->field_int (NULL
, regnum
);
1105 error (_("bad register number"));
1107 do_cleanups (cleanup
);
1111 register_changed_p (int regnum
, struct regcache
*prev_regs
,
1112 struct regcache
*this_regs
)
1114 struct gdbarch
*gdbarch
= get_regcache_arch (this_regs
);
1115 struct value
*prev_value
, *this_value
;
1118 /* First time through or after gdbarch change consider all registers
1120 if (!prev_regs
|| get_regcache_arch (prev_regs
) != gdbarch
)
1123 /* Get register contents and compare. */
1124 prev_value
= prev_regs
->cooked_read_value (regnum
);
1125 this_value
= this_regs
->cooked_read_value (regnum
);
1126 gdb_assert (prev_value
!= NULL
);
1127 gdb_assert (this_value
!= NULL
);
1129 ret
= value_contents_eq (prev_value
, 0, this_value
, 0,
1130 register_size (gdbarch
, regnum
)) == 0;
1132 release_value (prev_value
);
1133 release_value (this_value
);
1134 value_free (prev_value
);
1135 value_free (this_value
);
1139 /* Return a list of register number and value pairs. The valid
1140 arguments expected are: a letter indicating the format in which to
1141 display the registers contents. This can be one of: x
1142 (hexadecimal), d (decimal), N (natural), t (binary), o (octal), r
1143 (raw). After the format argument there can be a sequence of
1144 numbers, indicating which registers to fetch the content of. If
1145 the format is the only argument, a list of all the registers with
1146 their values is returned. */
1149 mi_cmd_data_list_register_values (const char *command
, char **argv
, int argc
)
1151 struct ui_out
*uiout
= current_uiout
;
1152 struct frame_info
*frame
;
1153 struct gdbarch
*gdbarch
;
1154 int regnum
, numregs
, format
;
1156 int skip_unavailable
= 0;
1162 static const struct mi_opt opts
[] =
1164 {"-skip-unavailable", SKIP_UNAVAILABLE
, 0},
1168 /* Note that the test for a valid register must include checking the
1169 gdbarch_register_name because gdbarch_num_regs may be allocated
1170 for the union of the register sets within a family of related
1171 processors. In this case, some entries of gdbarch_register_name
1172 will change depending upon the particular processor being
1178 int opt
= mi_getopt ("-data-list-register-values", argc
, argv
,
1179 opts
, &oind
, &oarg
);
1183 switch ((enum opt
) opt
)
1185 case SKIP_UNAVAILABLE
:
1186 skip_unavailable
= 1;
1191 if (argc
- oind
< 1)
1192 error (_("-data-list-register-values: Usage: "
1193 "-data-list-register-values [--skip-unavailable] <format>"
1194 " [<regnum1>...<regnumN>]"));
1196 format
= (int) argv
[oind
][0];
1198 frame
= get_selected_frame (NULL
);
1199 gdbarch
= get_frame_arch (frame
);
1200 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1202 ui_out_emit_list
list_emitter (uiout
, "register-values");
1204 if (argc
- oind
== 1)
1206 /* No args, beside the format: do all the regs. */
1211 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1212 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1215 output_register (frame
, regnum
, format
, skip_unavailable
);
1219 /* Else, list of register #s, just do listed regs. */
1220 for (i
= 1 + oind
; i
< argc
; i
++)
1222 regnum
= atoi (argv
[i
]);
1226 && gdbarch_register_name (gdbarch
, regnum
) != NULL
1227 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
1228 output_register (frame
, regnum
, format
, skip_unavailable
);
1230 error (_("bad register number"));
1234 /* Output one register REGNUM's contents in the desired FORMAT. If
1235 SKIP_UNAVAILABLE is true, skip the register if it is
1239 output_register (struct frame_info
*frame
, int regnum
, int format
,
1240 int skip_unavailable
)
1242 struct ui_out
*uiout
= current_uiout
;
1243 struct value
*val
= value_of_register (regnum
, frame
);
1244 struct value_print_options opts
;
1246 if (skip_unavailable
&& !value_entirely_available (val
))
1249 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1250 uiout
->field_int ("number", regnum
);
1260 get_formatted_print_options (&opts
, format
);
1262 val_print (value_type (val
),
1263 value_embedded_offset (val
), 0,
1264 &stb
, 0, val
, &opts
, current_language
);
1265 uiout
->field_stream ("value", stb
);
1268 /* Write given values into registers. The registers and values are
1269 given as pairs. The corresponding MI command is
1270 -data-write-register-values <format>
1271 [<regnum1> <value1>...<regnumN> <valueN>] */
1273 mi_cmd_data_write_register_values (const char *command
, char **argv
, int argc
)
1275 struct regcache
*regcache
;
1276 struct gdbarch
*gdbarch
;
1279 /* Note that the test for a valid register must include checking the
1280 gdbarch_register_name because gdbarch_num_regs may be allocated
1281 for the union of the register sets within a family of related
1282 processors. In this case, some entries of gdbarch_register_name
1283 will change depending upon the particular processor being
1286 regcache
= get_current_regcache ();
1287 gdbarch
= get_regcache_arch (regcache
);
1288 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1291 error (_("-data-write-register-values: Usage: -data-write-register-"
1292 "values <format> [<regnum1> <value1>...<regnumN> <valueN>]"));
1294 if (!target_has_registers
)
1295 error (_("-data-write-register-values: No registers."));
1298 error (_("-data-write-register-values: No regs and values specified."));
1301 error (_("-data-write-register-values: "
1302 "Regs and vals are not in pairs."));
1304 for (i
= 1; i
< argc
; i
= i
+ 2)
1306 int regnum
= atoi (argv
[i
]);
1308 if (regnum
>= 0 && regnum
< numregs
1309 && gdbarch_register_name (gdbarch
, regnum
)
1310 && *gdbarch_register_name (gdbarch
, regnum
))
1314 /* Get the value as a number. */
1315 value
= parse_and_eval_address (argv
[i
+ 1]);
1317 /* Write it down. */
1318 regcache_cooked_write_signed (regcache
, regnum
, value
);
1321 error (_("bad register number"));
1325 /* Evaluate the value of the argument. The argument is an
1326 expression. If the expression contains spaces it needs to be
1327 included in double quotes. */
1330 mi_cmd_data_evaluate_expression (const char *command
, char **argv
, int argc
)
1333 struct value_print_options opts
;
1334 struct ui_out
*uiout
= current_uiout
;
1337 error (_("-data-evaluate-expression: "
1338 "Usage: -data-evaluate-expression expression"));
1340 expression_up expr
= parse_expression (argv
[0]);
1342 val
= evaluate_expression (expr
.get ());
1346 /* Print the result of the expression evaluation. */
1347 get_user_print_options (&opts
);
1349 common_val_print (val
, &stb
, 0, &opts
, current_language
);
1351 uiout
->field_stream ("value", stb
);
1354 /* This is the -data-read-memory command.
1356 ADDR: start address of data to be dumped.
1357 WORD-FORMAT: a char indicating format for the ``word''. See
1359 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
1360 NR_ROW: Number of rows.
1361 NR_COL: The number of colums (words per row).
1362 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
1363 ASCHAR for unprintable characters.
1365 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
1366 displayes them. Returns:
1368 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
1371 The number of bytes read is SIZE*ROW*COL. */
1374 mi_cmd_data_read_memory (const char *command
, char **argv
, int argc
)
1376 struct gdbarch
*gdbarch
= get_current_arch ();
1377 struct ui_out
*uiout
= current_uiout
;
1379 long total_bytes
, nr_cols
, nr_rows
;
1381 struct type
*word_type
;
1393 static const struct mi_opt opts
[] =
1395 {"o", OFFSET_OPT
, 1},
1401 int opt
= mi_getopt ("-data-read-memory", argc
, argv
, opts
,
1406 switch ((enum opt
) opt
)
1409 offset
= atol (oarg
);
1416 if (argc
< 5 || argc
> 6)
1417 error (_("-data-read-memory: Usage: "
1418 "ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR]."));
1420 /* Extract all the arguments. */
1422 /* Start address of the memory dump. */
1423 addr
= parse_and_eval_address (argv
[0]) + offset
;
1424 /* The format character to use when displaying a memory word. See
1425 the ``x'' command. */
1426 word_format
= argv
[1][0];
1427 /* The size of the memory word. */
1428 word_size
= atol (argv
[2]);
1432 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1436 word_type
= builtin_type (gdbarch
)->builtin_int16
;
1440 word_type
= builtin_type (gdbarch
)->builtin_int32
;
1444 word_type
= builtin_type (gdbarch
)->builtin_int64
;
1448 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1451 /* The number of rows. */
1452 nr_rows
= atol (argv
[3]);
1454 error (_("-data-read-memory: invalid number of rows."));
1456 /* Number of bytes per row. */
1457 nr_cols
= atol (argv
[4]);
1459 error (_("-data-read-memory: invalid number of columns."));
1461 /* The un-printable character when printing ascii. */
1467 /* Create a buffer and read it in. */
1468 total_bytes
= word_size
* nr_rows
* nr_cols
;
1470 gdb::byte_vector
mbuf (total_bytes
);
1472 /* Dispatch memory reads to the topmost target, not the flattened
1474 nr_bytes
= target_read (current_target
.beneath
,
1475 TARGET_OBJECT_MEMORY
, NULL
, mbuf
.data (),
1478 error (_("Unable to read memory."));
1480 /* Output the header information. */
1481 uiout
->field_core_addr ("addr", gdbarch
, addr
);
1482 uiout
->field_int ("nr-bytes", nr_bytes
);
1483 uiout
->field_int ("total-bytes", total_bytes
);
1484 uiout
->field_core_addr ("next-row", gdbarch
, addr
+ word_size
* nr_cols
);
1485 uiout
->field_core_addr ("prev-row", gdbarch
, addr
- word_size
* nr_cols
);
1486 uiout
->field_core_addr ("next-page", gdbarch
, addr
+ total_bytes
);
1487 uiout
->field_core_addr ("prev-page", gdbarch
, addr
- total_bytes
);
1489 /* Build the result as a two dimentional table. */
1493 struct cleanup
*cleanup_list
;
1497 cleanup_list
= make_cleanup_ui_out_list_begin_end (uiout
, "memory");
1498 for (row
= 0, row_byte
= 0;
1500 row
++, row_byte
+= nr_cols
* word_size
)
1504 struct cleanup
*cleanup_list_data
;
1505 struct value_print_options opts
;
1507 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1508 uiout
->field_core_addr ("addr", gdbarch
, addr
+ row_byte
);
1509 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr +
1511 cleanup_list_data
= make_cleanup_ui_out_list_begin_end (uiout
, "data");
1512 get_formatted_print_options (&opts
, word_format
);
1513 for (col
= 0, col_byte
= row_byte
;
1515 col
++, col_byte
+= word_size
)
1517 if (col_byte
+ word_size
> nr_bytes
)
1519 uiout
->field_string (NULL
, "N/A");
1524 print_scalar_formatted (&mbuf
[col_byte
], word_type
, &opts
,
1525 word_asize
, &stream
);
1526 uiout
->field_stream (NULL
, stream
);
1529 do_cleanups (cleanup_list_data
);
1535 for (byte
= row_byte
;
1536 byte
< row_byte
+ word_size
* nr_cols
; byte
++)
1538 if (byte
>= nr_bytes
)
1540 else if (mbuf
[byte
] < 32 || mbuf
[byte
] > 126)
1541 stream
.putc (aschar
);
1543 stream
.putc (mbuf
[byte
]);
1545 uiout
->field_stream ("ascii", stream
);
1548 do_cleanups (cleanup_list
);
1553 mi_cmd_data_read_memory_bytes (const char *command
, char **argv
, int argc
)
1555 struct gdbarch
*gdbarch
= get_current_arch ();
1556 struct ui_out
*uiout
= current_uiout
;
1557 struct cleanup
*cleanups
;
1560 memory_read_result_s
*read_result
;
1562 VEC(memory_read_result_s
) *result
;
1564 int unit_size
= gdbarch_addressable_memory_unit_size (gdbarch
);
1571 static const struct mi_opt opts
[] =
1573 {"o", OFFSET_OPT
, 1},
1579 int opt
= mi_getopt ("-data-read-memory-bytes", argc
, argv
, opts
,
1583 switch ((enum opt
) opt
)
1586 offset
= atol (oarg
);
1594 error (_("Usage: [ -o OFFSET ] ADDR LENGTH."));
1596 addr
= parse_and_eval_address (argv
[0]) + offset
;
1597 length
= atol (argv
[1]);
1599 result
= read_memory_robust (current_target
.beneath
, addr
, length
);
1601 cleanups
= make_cleanup (free_memory_read_result_vector
, &result
);
1603 if (VEC_length (memory_read_result_s
, result
) == 0)
1604 error (_("Unable to read memory."));
1606 make_cleanup_ui_out_list_begin_end (uiout
, "memory");
1608 VEC_iterate (memory_read_result_s
, result
, ix
, read_result
);
1611 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1616 uiout
->field_core_addr ("begin", gdbarch
, read_result
->begin
);
1617 uiout
->field_core_addr ("offset", gdbarch
, read_result
->begin
- addr
);
1618 uiout
->field_core_addr ("end", gdbarch
, read_result
->end
);
1620 alloc_len
= (read_result
->end
- read_result
->begin
) * 2 * unit_size
+ 1;
1621 data
= (char *) xmalloc (alloc_len
);
1623 for (i
= 0, p
= data
;
1624 i
< ((read_result
->end
- read_result
->begin
) * unit_size
);
1627 sprintf (p
, "%02x", read_result
->data
[i
]);
1629 uiout
->field_string ("contents", data
);
1632 do_cleanups (cleanups
);
1635 /* Implementation of the -data-write_memory command.
1637 COLUMN_OFFSET: optional argument. Must be preceded by '-o'. The
1638 offset from the beginning of the memory grid row where the cell to
1640 ADDR: start address of the row in the memory grid where the memory
1641 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
1642 the location to write to.
1643 FORMAT: a char indicating format for the ``word''. See
1645 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
1646 VALUE: value to be written into the memory address.
1648 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1653 mi_cmd_data_write_memory (const char *command
, char **argv
, int argc
)
1655 struct gdbarch
*gdbarch
= get_current_arch ();
1656 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1659 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1660 enough when using a compiler other than GCC. */
1663 struct cleanup
*old_chain
;
1671 static const struct mi_opt opts
[] =
1673 {"o", OFFSET_OPT
, 1},
1679 int opt
= mi_getopt ("-data-write-memory", argc
, argv
, opts
,
1684 switch ((enum opt
) opt
)
1687 offset
= atol (oarg
);
1695 error (_("-data-write-memory: Usage: "
1696 "[-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE."));
1698 /* Extract all the arguments. */
1699 /* Start address of the memory dump. */
1700 addr
= parse_and_eval_address (argv
[0]);
1701 /* The size of the memory word. */
1702 word_size
= atol (argv
[2]);
1704 /* Calculate the real address of the write destination. */
1705 addr
+= (offset
* word_size
);
1707 /* Get the value as a number. */
1708 value
= parse_and_eval_address (argv
[3]);
1709 /* Get the value into an array. */
1710 buffer
= (gdb_byte
*) xmalloc (word_size
);
1711 old_chain
= make_cleanup (xfree
, buffer
);
1712 store_signed_integer (buffer
, word_size
, byte_order
, value
);
1713 /* Write it down to memory. */
1714 write_memory_with_notification (addr
, buffer
, word_size
);
1715 /* Free the buffer. */
1716 do_cleanups (old_chain
);
1719 /* Implementation of the -data-write-memory-bytes command.
1722 DATA: string of bytes to write at that address
1723 COUNT: number of bytes to be filled (decimal integer). */
1726 mi_cmd_data_write_memory_bytes (const char *command
, char **argv
, int argc
)
1732 size_t len_hex
, len_bytes
, len_units
, i
, steps
, remaining_units
;
1733 long int count_units
;
1734 struct cleanup
*back_to
;
1737 if (argc
!= 2 && argc
!= 3)
1738 error (_("Usage: ADDR DATA [COUNT]."));
1740 addr
= parse_and_eval_address (argv
[0]);
1742 len_hex
= strlen (cdata
);
1743 unit_size
= gdbarch_addressable_memory_unit_size (get_current_arch ());
1745 if (len_hex
% (unit_size
* 2) != 0)
1746 error (_("Hex-encoded '%s' must represent an integral number of "
1747 "addressable memory units."),
1750 len_bytes
= len_hex
/ 2;
1751 len_units
= len_bytes
/ unit_size
;
1754 count_units
= strtoul (argv
[2], NULL
, 10);
1756 count_units
= len_units
;
1758 databuf
= XNEWVEC (gdb_byte
, len_bytes
);
1759 back_to
= make_cleanup (xfree
, databuf
);
1761 for (i
= 0; i
< len_bytes
; ++i
)
1764 if (sscanf (cdata
+ i
* 2, "%02x", &x
) != 1)
1765 error (_("Invalid argument"));
1766 databuf
[i
] = (gdb_byte
) x
;
1769 if (len_units
< count_units
)
1771 /* Pattern is made of less units than count:
1772 repeat pattern to fill memory. */
1773 data
= (gdb_byte
*) xmalloc (count_units
* unit_size
);
1774 make_cleanup (xfree
, data
);
1776 /* Number of times the pattern is entirely repeated. */
1777 steps
= count_units
/ len_units
;
1778 /* Number of remaining addressable memory units. */
1779 remaining_units
= count_units
% len_units
;
1780 for (i
= 0; i
< steps
; i
++)
1781 memcpy (data
+ i
* len_bytes
, databuf
, len_bytes
);
1783 if (remaining_units
> 0)
1784 memcpy (data
+ steps
* len_bytes
, databuf
,
1785 remaining_units
* unit_size
);
1789 /* Pattern is longer than or equal to count:
1790 just copy count addressable memory units. */
1794 write_memory_with_notification (addr
, data
, count_units
);
1796 do_cleanups (back_to
);
1800 mi_cmd_enable_timings (const char *command
, char **argv
, int argc
)
1806 if (strcmp (argv
[0], "yes") == 0)
1808 else if (strcmp (argv
[0], "no") == 0)
1819 error (_("-enable-timings: Usage: %s {yes|no}"), command
);
1823 mi_cmd_list_features (const char *command
, char **argv
, int argc
)
1827 struct ui_out
*uiout
= current_uiout
;
1829 ui_out_emit_list
list_emitter (uiout
, "features");
1830 uiout
->field_string (NULL
, "frozen-varobjs");
1831 uiout
->field_string (NULL
, "pending-breakpoints");
1832 uiout
->field_string (NULL
, "thread-info");
1833 uiout
->field_string (NULL
, "data-read-memory-bytes");
1834 uiout
->field_string (NULL
, "breakpoint-notifications");
1835 uiout
->field_string (NULL
, "ada-task-info");
1836 uiout
->field_string (NULL
, "language-option");
1837 uiout
->field_string (NULL
, "info-gdb-mi-command");
1838 uiout
->field_string (NULL
, "undefined-command-error-code");
1839 uiout
->field_string (NULL
, "exec-run-start-option");
1841 if (ext_lang_initialized_p (get_ext_lang_defn (EXT_LANG_PYTHON
)))
1842 uiout
->field_string (NULL
, "python");
1847 error (_("-list-features should be passed no arguments"));
1851 mi_cmd_list_target_features (const char *command
, char **argv
, int argc
)
1855 struct ui_out
*uiout
= current_uiout
;
1857 ui_out_emit_list
list_emitter (uiout
, "features");
1859 uiout
->field_string (NULL
, "async");
1860 if (target_can_execute_reverse
)
1861 uiout
->field_string (NULL
, "reverse");
1865 error (_("-list-target-features should be passed no arguments"));
1869 mi_cmd_add_inferior (const char *command
, char **argv
, int argc
)
1871 struct inferior
*inf
;
1874 error (_("-add-inferior should be passed no arguments"));
1876 inf
= add_inferior_with_spaces ();
1878 current_uiout
->field_fmt ("inferior", "i%d", inf
->num
);
1881 /* Callback used to find the first inferior other than the current
1885 get_other_inferior (struct inferior
*inf
, void *arg
)
1887 if (inf
== current_inferior ())
1894 mi_cmd_remove_inferior (const char *command
, char **argv
, int argc
)
1897 struct inferior
*inf
;
1900 error (_("-remove-inferior should be passed a single argument"));
1902 if (sscanf (argv
[0], "i%d", &id
) != 1)
1903 error (_("the thread group id is syntactically invalid"));
1905 inf
= find_inferior_id (id
);
1907 error (_("the specified thread group does not exist"));
1910 error (_("cannot remove an active inferior"));
1912 if (inf
== current_inferior ())
1914 struct thread_info
*tp
= 0;
1915 struct inferior
*new_inferior
1916 = iterate_over_inferiors (get_other_inferior
, NULL
);
1918 if (new_inferior
== NULL
)
1919 error (_("Cannot remove last inferior"));
1921 set_current_inferior (new_inferior
);
1922 if (new_inferior
->pid
!= 0)
1923 tp
= any_thread_of_process (new_inferior
->pid
);
1924 switch_to_thread (tp
? tp
->ptid
: null_ptid
);
1925 set_current_program_space (new_inferior
->pspace
);
1928 delete_inferior (inf
);
1933 /* Execute a command within a safe environment.
1934 Return <0 for error; >=0 for ok.
1936 args->action will tell mi_execute_command what action
1937 to perfrom after the given command has executed (display/suppress
1938 prompt, display error). */
1941 captured_mi_execute_command (struct ui_out
*uiout
, struct mi_parse
*context
)
1943 struct mi_interp
*mi
= (struct mi_interp
*) command_interp ();
1944 struct cleanup
*cleanup
;
1947 current_command_ts
= context
->cmd_start
;
1949 current_token
= xstrdup (context
->token
);
1950 cleanup
= make_cleanup (free_current_contents
, ¤t_token
);
1952 running_result_record_printed
= 0;
1954 switch (context
->op
)
1957 /* A MI command was read from the input stream. */
1959 /* FIXME: gdb_???? */
1960 fprintf_unfiltered (mi
->raw_stdout
,
1961 " token=`%s' command=`%s' args=`%s'\n",
1962 context
->token
, context
->command
, context
->args
);
1964 mi_cmd_execute (context
);
1966 /* Print the result if there were no errors.
1968 Remember that on the way out of executing a command, you have
1969 to directly use the mi_interp's uiout, since the command
1970 could have reset the interpreter, in which case the current
1971 uiout will most likely crash in the mi_out_* routines. */
1972 if (!running_result_record_printed
)
1974 fputs_unfiltered (context
->token
, mi
->raw_stdout
);
1975 /* There's no particularly good reason why target-connect results
1976 in not ^done. Should kill ^connected for MI3. */
1977 fputs_unfiltered (strcmp (context
->command
, "target-select") == 0
1978 ? "^connected" : "^done", mi
->raw_stdout
);
1979 mi_out_put (uiout
, mi
->raw_stdout
);
1980 mi_out_rewind (uiout
);
1981 mi_print_timing_maybe (mi
->raw_stdout
);
1982 fputs_unfiltered ("\n", mi
->raw_stdout
);
1985 /* The command does not want anything to be printed. In that
1986 case, the command probably should not have written anything
1987 to uiout, but in case it has written something, discard it. */
1988 mi_out_rewind (uiout
);
1995 /* A CLI command was read from the input stream. */
1996 /* This "feature" will be removed as soon as we have a
1997 complete set of mi commands. */
1998 /* Echo the command on the console. */
1999 fprintf_unfiltered (gdb_stdlog
, "%s\n", context
->command
);
2000 /* Call the "console" interpreter. */
2001 argv
[0] = (char *) INTERP_CONSOLE
;
2002 argv
[1] = context
->command
;
2003 mi_cmd_interpreter_exec ("-interpreter-exec", argv
, 2);
2005 /* If we changed interpreters, DON'T print out anything. */
2006 if (current_interp_named_p (INTERP_MI
)
2007 || current_interp_named_p (INTERP_MI1
)
2008 || current_interp_named_p (INTERP_MI2
)
2009 || current_interp_named_p (INTERP_MI3
))
2011 if (!running_result_record_printed
)
2013 fputs_unfiltered (context
->token
, mi
->raw_stdout
);
2014 fputs_unfiltered ("^done", mi
->raw_stdout
);
2015 mi_out_put (uiout
, mi
->raw_stdout
);
2016 mi_out_rewind (uiout
);
2017 mi_print_timing_maybe (mi
->raw_stdout
);
2018 fputs_unfiltered ("\n", mi
->raw_stdout
);
2021 mi_out_rewind (uiout
);
2027 do_cleanups (cleanup
);
2030 /* Print a gdb exception to the MI output stream. */
2033 mi_print_exception (const char *token
, struct gdb_exception exception
)
2035 struct mi_interp
*mi
= (struct mi_interp
*) current_interpreter ();
2037 fputs_unfiltered (token
, mi
->raw_stdout
);
2038 fputs_unfiltered ("^error,msg=\"", mi
->raw_stdout
);
2039 if (exception
.message
== NULL
)
2040 fputs_unfiltered ("unknown error", mi
->raw_stdout
);
2042 fputstr_unfiltered (exception
.message
, '"', mi
->raw_stdout
);
2043 fputs_unfiltered ("\"", mi
->raw_stdout
);
2045 switch (exception
.error
)
2047 case UNDEFINED_COMMAND_ERROR
:
2048 fputs_unfiltered (",code=\"undefined-command\"", mi
->raw_stdout
);
2052 fputs_unfiltered ("\n", mi
->raw_stdout
);
2055 /* Determine whether the parsed command already notifies the
2056 user_selected_context_changed observer. */
2059 command_notifies_uscc_observer (struct mi_parse
*command
)
2061 if (command
->op
== CLI_COMMAND
)
2063 /* CLI commands "thread" and "inferior" already send it. */
2064 return (strncmp (command
->command
, "thread ", 7) == 0
2065 || strncmp (command
->command
, "inferior ", 9) == 0);
2067 else /* MI_COMMAND */
2069 if (strcmp (command
->command
, "interpreter-exec") == 0
2070 && command
->argc
> 1)
2072 /* "thread" and "inferior" again, but through -interpreter-exec. */
2073 return (strncmp (command
->argv
[1], "thread ", 7) == 0
2074 || strncmp (command
->argv
[1], "inferior ", 9) == 0);
2078 /* -thread-select already sends it. */
2079 return strcmp (command
->command
, "thread-select") == 0;
2084 mi_execute_command (const char *cmd
, int from_tty
)
2087 std::unique_ptr
<struct mi_parse
> command
;
2089 /* This is to handle EOF (^D). We just quit gdb. */
2090 /* FIXME: we should call some API function here. */
2092 quit_force (NULL
, from_tty
);
2094 target_log_command (cmd
);
2098 command
= mi_parse (cmd
, &token
);
2100 CATCH (exception
, RETURN_MASK_ALL
)
2102 mi_print_exception (token
, exception
);
2107 if (command
!= NULL
)
2109 ptid_t previous_ptid
= inferior_ptid
;
2111 gdb::optional
<scoped_restore_tmpl
<int>> restore_suppress
;
2113 if (command
->cmd
!= NULL
&& command
->cmd
->suppress_notification
!= NULL
)
2114 restore_suppress
.emplace (command
->cmd
->suppress_notification
, 1);
2116 command
->token
= token
;
2120 command
->cmd_start
= new mi_timestamp ();
2121 timestamp (command
->cmd_start
);
2126 captured_mi_execute_command (current_uiout
, command
.get ());
2128 CATCH (result
, RETURN_MASK_ALL
)
2130 /* Like in start_event_loop, enable input and force display
2131 of the prompt. Otherwise, any command that calls
2132 async_disable_stdin, and then throws, will leave input
2134 async_enable_stdin ();
2135 current_ui
->prompt_state
= PROMPT_NEEDED
;
2137 /* The command execution failed and error() was called
2139 mi_print_exception (command
->token
, result
);
2140 mi_out_rewind (current_uiout
);
2144 bpstat_do_actions ();
2146 if (/* The notifications are only output when the top-level
2147 interpreter (specified on the command line) is MI. */
2148 interp_ui_out (top_level_interpreter ())->is_mi_like_p ()
2149 /* Don't try report anything if there are no threads --
2150 the program is dead. */
2151 && thread_count () != 0
2152 /* If the command already reports the thread change, no need to do it
2154 && !command_notifies_uscc_observer (command
.get ()))
2156 struct mi_interp
*mi
= (struct mi_interp
*) top_level_interpreter ();
2157 int report_change
= 0;
2159 if (command
->thread
== -1)
2161 report_change
= (!ptid_equal (previous_ptid
, null_ptid
)
2162 && !ptid_equal (inferior_ptid
, previous_ptid
)
2163 && !ptid_equal (inferior_ptid
, null_ptid
));
2165 else if (!ptid_equal (inferior_ptid
, null_ptid
))
2167 struct thread_info
*ti
= inferior_thread ();
2169 report_change
= (ti
->global_num
!= command
->thread
);
2174 observer_notify_user_selected_context_changed
2175 (USER_SELECTED_THREAD
| USER_SELECTED_FRAME
);
2182 mi_cmd_execute (struct mi_parse
*parse
)
2184 struct cleanup
*cleanup
;
2186 cleanup
= prepare_execute_command ();
2188 if (parse
->all
&& parse
->thread_group
!= -1)
2189 error (_("Cannot specify --thread-group together with --all"));
2191 if (parse
->all
&& parse
->thread
!= -1)
2192 error (_("Cannot specify --thread together with --all"));
2194 if (parse
->thread_group
!= -1 && parse
->thread
!= -1)
2195 error (_("Cannot specify --thread together with --thread-group"));
2197 if (parse
->frame
!= -1 && parse
->thread
== -1)
2198 error (_("Cannot specify --frame without --thread"));
2200 if (parse
->thread_group
!= -1)
2202 struct inferior
*inf
= find_inferior_id (parse
->thread_group
);
2203 struct thread_info
*tp
= 0;
2206 error (_("Invalid thread group for the --thread-group option"));
2208 set_current_inferior (inf
);
2209 /* This behaviour means that if --thread-group option identifies
2210 an inferior with multiple threads, then a random one will be
2211 picked. This is not a problem -- frontend should always
2212 provide --thread if it wishes to operate on a specific
2215 tp
= any_live_thread_of_process (inf
->pid
);
2216 switch_to_thread (tp
? tp
->ptid
: null_ptid
);
2217 set_current_program_space (inf
->pspace
);
2220 if (parse
->thread
!= -1)
2222 struct thread_info
*tp
= find_thread_global_id (parse
->thread
);
2225 error (_("Invalid thread id: %d"), parse
->thread
);
2227 if (is_exited (tp
->ptid
))
2228 error (_("Thread id: %d has terminated"), parse
->thread
);
2230 switch_to_thread (tp
->ptid
);
2233 if (parse
->frame
!= -1)
2235 struct frame_info
*fid
;
2236 int frame
= parse
->frame
;
2238 fid
= find_relative_frame (get_current_frame (), &frame
);
2240 /* find_relative_frame was successful */
2243 error (_("Invalid frame id: %d"), frame
);
2246 if (parse
->language
!= language_unknown
)
2248 make_cleanup_restore_current_language ();
2249 set_language (parse
->language
);
2252 current_context
= parse
;
2254 if (parse
->cmd
->argv_func
!= NULL
)
2256 parse
->cmd
->argv_func (parse
->command
, parse
->argv
, parse
->argc
);
2258 else if (parse
->cmd
->cli
.cmd
!= 0)
2260 /* FIXME: DELETE THIS. */
2261 /* The operation is still implemented by a cli command. */
2262 /* Must be a synchronous one. */
2263 mi_execute_cli_command (parse
->cmd
->cli
.cmd
, parse
->cmd
->cli
.args_p
,
2268 /* FIXME: DELETE THIS. */
2271 stb
.puts ("Undefined mi command: ");
2272 stb
.putstr (parse
->command
, '"');
2273 stb
.puts (" (missing implementation)");
2277 do_cleanups (cleanup
);
2280 /* FIXME: This is just a hack so we can get some extra commands going.
2281 We don't want to channel things through the CLI, but call libgdb directly.
2282 Use only for synchronous commands. */
2285 mi_execute_cli_command (const char *cmd
, int args_p
, const char *args
)
2289 struct cleanup
*old_cleanups
;
2293 run
= xstrprintf ("%s %s", cmd
, args
);
2295 run
= xstrdup (cmd
);
2297 /* FIXME: gdb_???? */
2298 fprintf_unfiltered (gdb_stdout
, "cli=%s run=%s\n",
2300 old_cleanups
= make_cleanup (xfree
, run
);
2301 execute_command (run
, 0 /* from_tty */ );
2302 do_cleanups (old_cleanups
);
2308 mi_execute_async_cli_command (const char *cli_command
, char **argv
, int argc
)
2310 struct cleanup
*old_cleanups
;
2314 run
= xstrprintf ("%s %s&", cli_command
, argc
? *argv
: "");
2316 run
= xstrprintf ("%s %s", cli_command
, argc
? *argv
: "");
2317 old_cleanups
= make_cleanup (xfree
, run
);
2319 execute_command (run
, 0 /* from_tty */ );
2321 /* Do this before doing any printing. It would appear that some
2322 print code leaves garbage around in the buffer. */
2323 do_cleanups (old_cleanups
);
2327 mi_load_progress (const char *section_name
,
2328 unsigned long sent_so_far
,
2329 unsigned long total_section
,
2330 unsigned long total_sent
,
2331 unsigned long grand_total
)
2333 using namespace std::chrono
;
2334 static steady_clock::time_point last_update
;
2335 static char *previous_sect_name
= NULL
;
2337 struct ui_out
*saved_uiout
;
2338 struct ui_out
*uiout
;
2339 struct mi_interp
*mi
= (struct mi_interp
*) current_interpreter ();
2341 /* This function is called through deprecated_show_load_progress
2342 which means uiout may not be correct. Fix it for the duration
2343 of this function. */
2344 saved_uiout
= current_uiout
;
2346 if (current_interp_named_p (INTERP_MI
)
2347 || current_interp_named_p (INTERP_MI2
))
2348 current_uiout
= mi_out_new (2);
2349 else if (current_interp_named_p (INTERP_MI1
))
2350 current_uiout
= mi_out_new (1);
2351 else if (current_interp_named_p (INTERP_MI3
))
2352 current_uiout
= mi_out_new (3);
2356 uiout
= current_uiout
;
2358 new_section
= (previous_sect_name
?
2359 strcmp (previous_sect_name
, section_name
) : 1);
2362 xfree (previous_sect_name
);
2363 previous_sect_name
= xstrdup (section_name
);
2366 fputs_unfiltered (current_token
, mi
->raw_stdout
);
2367 fputs_unfiltered ("+download", mi
->raw_stdout
);
2369 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
2370 uiout
->field_string ("section", section_name
);
2371 uiout
->field_int ("section-size", total_section
);
2372 uiout
->field_int ("total-size", grand_total
);
2374 mi_out_put (uiout
, mi
->raw_stdout
);
2375 fputs_unfiltered ("\n", mi
->raw_stdout
);
2376 gdb_flush (mi
->raw_stdout
);
2379 steady_clock::time_point time_now
= steady_clock::now ();
2380 if (time_now
- last_update
> milliseconds (500))
2382 last_update
= time_now
;
2384 fputs_unfiltered (current_token
, mi
->raw_stdout
);
2385 fputs_unfiltered ("+download", mi
->raw_stdout
);
2387 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
2388 uiout
->field_string ("section", section_name
);
2389 uiout
->field_int ("section-sent", sent_so_far
);
2390 uiout
->field_int ("section-size", total_section
);
2391 uiout
->field_int ("total-sent", total_sent
);
2392 uiout
->field_int ("total-size", grand_total
);
2394 mi_out_put (uiout
, mi
->raw_stdout
);
2395 fputs_unfiltered ("\n", mi
->raw_stdout
);
2396 gdb_flush (mi
->raw_stdout
);
2400 current_uiout
= saved_uiout
;
2404 timestamp (struct mi_timestamp
*tv
)
2406 using namespace std::chrono
;
2408 tv
->wallclock
= steady_clock::now ();
2409 run_time_clock::now (tv
->utime
, tv
->stime
);
2413 print_diff_now (struct ui_file
*file
, struct mi_timestamp
*start
)
2415 struct mi_timestamp now
;
2418 print_diff (file
, start
, &now
);
2422 mi_print_timing_maybe (struct ui_file
*file
)
2424 /* If the command is -enable-timing then do_timings may be true
2425 whilst current_command_ts is not initialized. */
2426 if (do_timings
&& current_command_ts
)
2427 print_diff_now (file
, current_command_ts
);
2431 print_diff (struct ui_file
*file
, struct mi_timestamp
*start
,
2432 struct mi_timestamp
*end
)
2434 using namespace std::chrono
;
2436 duration
<double> wallclock
= end
->wallclock
- start
->wallclock
;
2437 duration
<double> utime
= end
->utime
- start
->utime
;
2438 duration
<double> stime
= end
->stime
- start
->stime
;
2442 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
2443 wallclock
.count (), utime
.count (), stime
.count ());
2447 mi_cmd_trace_define_variable (const char *command
, char **argv
, int argc
)
2449 LONGEST initval
= 0;
2450 struct trace_state_variable
*tsv
;
2453 if (argc
!= 1 && argc
!= 2)
2454 error (_("Usage: -trace-define-variable VARIABLE [VALUE]"));
2458 error (_("Name of trace variable should start with '$'"));
2460 validate_trace_state_variable_name (name
);
2462 tsv
= find_trace_state_variable (name
);
2464 tsv
= create_trace_state_variable (name
);
2467 initval
= value_as_long (parse_and_eval (argv
[1]));
2469 tsv
->initial_value
= initval
;
2473 mi_cmd_trace_list_variables (const char *command
, char **argv
, int argc
)
2476 error (_("-trace-list-variables: no arguments allowed"));
2478 tvariables_info_1 ();
2482 mi_cmd_trace_find (const char *command
, char **argv
, int argc
)
2487 error (_("trace selection mode is required"));
2491 if (strcmp (mode
, "none") == 0)
2493 tfind_1 (tfind_number
, -1, 0, 0, 0);
2497 check_trace_running (current_trace_status ());
2499 if (strcmp (mode
, "frame-number") == 0)
2502 error (_("frame number is required"));
2503 tfind_1 (tfind_number
, atoi (argv
[1]), 0, 0, 0);
2505 else if (strcmp (mode
, "tracepoint-number") == 0)
2508 error (_("tracepoint number is required"));
2509 tfind_1 (tfind_tp
, atoi (argv
[1]), 0, 0, 0);
2511 else if (strcmp (mode
, "pc") == 0)
2514 error (_("PC is required"));
2515 tfind_1 (tfind_pc
, 0, parse_and_eval_address (argv
[1]), 0, 0);
2517 else if (strcmp (mode
, "pc-inside-range") == 0)
2520 error (_("Start and end PC are required"));
2521 tfind_1 (tfind_range
, 0, parse_and_eval_address (argv
[1]),
2522 parse_and_eval_address (argv
[2]), 0);
2524 else if (strcmp (mode
, "pc-outside-range") == 0)
2527 error (_("Start and end PC are required"));
2528 tfind_1 (tfind_outside
, 0, parse_and_eval_address (argv
[1]),
2529 parse_and_eval_address (argv
[2]), 0);
2531 else if (strcmp (mode
, "line") == 0)
2533 struct symtabs_and_lines sals
;
2534 struct symtab_and_line sal
;
2535 static CORE_ADDR start_pc
, end_pc
;
2536 struct cleanup
*back_to
;
2539 error (_("Line is required"));
2541 sals
= decode_line_with_current_source (argv
[1],
2542 DECODE_LINE_FUNFIRSTLINE
);
2543 back_to
= make_cleanup (xfree
, sals
.sals
);
2547 if (sal
.symtab
== 0)
2548 error (_("Could not find the specified line"));
2550 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2551 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, 0);
2553 error (_("Could not find the specified line"));
2555 do_cleanups (back_to
);
2558 error (_("Invalid mode '%s'"), mode
);
2560 if (has_stack_frames () || get_traceframe_number () >= 0)
2561 print_stack_frame (get_selected_frame (NULL
), 1, LOC_AND_ADDRESS
, 1);
2565 mi_cmd_trace_save (const char *command
, char **argv
, int argc
)
2567 int target_saves
= 0;
2568 int generate_ctf
= 0;
2575 TARGET_SAVE_OPT
, CTF_OPT
2577 static const struct mi_opt opts
[] =
2579 {"r", TARGET_SAVE_OPT
, 0},
2580 {"ctf", CTF_OPT
, 0},
2586 int opt
= mi_getopt ("-trace-save", argc
, argv
, opts
,
2591 switch ((enum opt
) opt
)
2593 case TARGET_SAVE_OPT
:
2602 if (argc
- oind
!= 1)
2603 error (_("Exactly one argument required "
2604 "(file in which to save trace data)"));
2606 filename
= argv
[oind
];
2609 trace_save_ctf (filename
, target_saves
);
2611 trace_save_tfile (filename
, target_saves
);
2615 mi_cmd_trace_start (const char *command
, char **argv
, int argc
)
2617 start_tracing (NULL
);
2621 mi_cmd_trace_status (const char *command
, char **argv
, int argc
)
2623 trace_status_mi (0);
2627 mi_cmd_trace_stop (const char *command
, char **argv
, int argc
)
2629 stop_tracing (NULL
);
2630 trace_status_mi (1);
2633 /* Implement the "-ada-task-info" command. */
2636 mi_cmd_ada_task_info (const char *command
, char **argv
, int argc
)
2638 if (argc
!= 0 && argc
!= 1)
2639 error (_("Invalid MI command"));
2641 print_ada_task_info (current_uiout
, argv
[0], current_inferior ());
2644 /* Print EXPRESSION according to VALUES. */
2647 print_variable_or_computed (const char *expression
, enum print_values values
)
2651 struct ui_out
*uiout
= current_uiout
;
2655 expression_up expr
= parse_expression (expression
);
2657 if (values
== PRINT_SIMPLE_VALUES
)
2658 val
= evaluate_type (expr
.get ());
2660 val
= evaluate_expression (expr
.get ());
2662 gdb::optional
<ui_out_emit_tuple
> tuple_emitter
;
2663 if (values
!= PRINT_NO_VALUES
)
2664 tuple_emitter
.emplace (uiout
, nullptr);
2665 uiout
->field_string ("name", expression
);
2669 case PRINT_SIMPLE_VALUES
:
2670 type
= check_typedef (value_type (val
));
2671 type_print (value_type (val
), "", &stb
, -1);
2672 uiout
->field_stream ("type", stb
);
2673 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
2674 && TYPE_CODE (type
) != TYPE_CODE_STRUCT
2675 && TYPE_CODE (type
) != TYPE_CODE_UNION
)
2677 struct value_print_options opts
;
2679 get_no_prettyformat_print_options (&opts
);
2681 common_val_print (val
, &stb
, 0, &opts
, current_language
);
2682 uiout
->field_stream ("value", stb
);
2685 case PRINT_ALL_VALUES
:
2687 struct value_print_options opts
;
2689 get_no_prettyformat_print_options (&opts
);
2691 common_val_print (val
, &stb
, 0, &opts
, current_language
);
2692 uiout
->field_stream ("value", stb
);
2698 /* Implement the "-trace-frame-collected" command. */
2701 mi_cmd_trace_frame_collected (const char *command
, char **argv
, int argc
)
2703 struct bp_location
*tloc
;
2705 struct collection_list
*clist
;
2706 struct collection_list tracepoint_list
, stepping_list
;
2707 struct traceframe_info
*tinfo
;
2709 enum print_values var_print_values
= PRINT_ALL_VALUES
;
2710 enum print_values comp_print_values
= PRINT_ALL_VALUES
;
2711 int registers_format
= 'x';
2712 int memory_contents
= 0;
2713 struct ui_out
*uiout
= current_uiout
;
2721 static const struct mi_opt opts
[] =
2723 {"-var-print-values", VAR_PRINT_VALUES
, 1},
2724 {"-comp-print-values", COMP_PRINT_VALUES
, 1},
2725 {"-registers-format", REGISTERS_FORMAT
, 1},
2726 {"-memory-contents", MEMORY_CONTENTS
, 0},
2733 int opt
= mi_getopt ("-trace-frame-collected", argc
, argv
, opts
,
2737 switch ((enum opt
) opt
)
2739 case VAR_PRINT_VALUES
:
2740 var_print_values
= mi_parse_print_values (oarg
);
2742 case COMP_PRINT_VALUES
:
2743 comp_print_values
= mi_parse_print_values (oarg
);
2745 case REGISTERS_FORMAT
:
2746 registers_format
= oarg
[0];
2747 case MEMORY_CONTENTS
:
2748 memory_contents
= 1;
2754 error (_("Usage: -trace-frame-collected "
2755 "[--var-print-values PRINT_VALUES] "
2756 "[--comp-print-values PRINT_VALUES] "
2757 "[--registers-format FORMAT]"
2758 "[--memory-contents]"));
2760 /* This throws an error is not inspecting a trace frame. */
2761 tloc
= get_traceframe_location (&stepping_frame
);
2763 /* This command only makes sense for the current frame, not the
2765 scoped_restore_current_thread restore_thread
;
2766 select_frame (get_current_frame ());
2768 encode_actions (tloc
, &tracepoint_list
, &stepping_list
);
2771 clist
= &stepping_list
;
2773 clist
= &tracepoint_list
;
2775 tinfo
= get_traceframe_info ();
2777 /* Explicitly wholly collected variables. */
2781 ui_out_emit_list
list_emitter (uiout
, "explicit-variables");
2782 const std::vector
<std::string
> &wholly_collected
2783 = clist
->wholly_collected ();
2784 for (size_t i
= 0; i
< wholly_collected
.size (); i
++)
2786 const std::string
&str
= wholly_collected
[i
];
2787 print_variable_or_computed (str
.c_str (), var_print_values
);
2791 /* Computed expressions. */
2796 ui_out_emit_list
list_emitter (uiout
, "computed-expressions");
2798 const std::vector
<std::string
> &computed
= clist
->computed ();
2799 for (size_t i
= 0; i
< computed
.size (); i
++)
2801 const std::string
&str
= computed
[i
];
2802 print_variable_or_computed (str
.c_str (), comp_print_values
);
2806 /* Registers. Given pseudo-registers, and that some architectures
2807 (like MIPS) actually hide the raw registers, we don't go through
2808 the trace frame info, but instead consult the register cache for
2809 register availability. */
2811 struct frame_info
*frame
;
2812 struct gdbarch
*gdbarch
;
2816 ui_out_emit_list
list_emitter (uiout
, "registers");
2818 frame
= get_selected_frame (NULL
);
2819 gdbarch
= get_frame_arch (frame
);
2820 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
2822 for (regnum
= 0; regnum
< numregs
; regnum
++)
2824 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
2825 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
2828 output_register (frame
, regnum
, registers_format
, 1);
2832 /* Trace state variables. */
2834 struct cleanup
*list_cleanup
;
2839 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "tvars");
2842 make_cleanup (free_current_contents
, &tsvname
);
2844 for (i
= 0; VEC_iterate (int, tinfo
->tvars
, i
, tvar
); i
++)
2846 struct trace_state_variable
*tsv
;
2848 tsv
= find_trace_state_variable_by_number (tvar
);
2850 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
2854 tsvname
= (char *) xrealloc (tsvname
, strlen (tsv
->name
) + 2);
2856 strcpy (tsvname
+ 1, tsv
->name
);
2857 uiout
->field_string ("name", tsvname
);
2859 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
2861 uiout
->field_int ("current", tsv
->value
);
2865 uiout
->field_skip ("name");
2866 uiout
->field_skip ("current");
2870 do_cleanups (list_cleanup
);
2875 struct cleanup
*list_cleanup
;
2876 VEC(mem_range_s
) *available_memory
= NULL
;
2877 struct mem_range
*r
;
2880 traceframe_available_memory (&available_memory
, 0, ULONGEST_MAX
);
2881 make_cleanup (VEC_cleanup(mem_range_s
), &available_memory
);
2883 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "memory");
2885 for (i
= 0; VEC_iterate (mem_range_s
, available_memory
, i
, r
); i
++)
2887 struct cleanup
*cleanup_child
;
2889 struct gdbarch
*gdbarch
= target_gdbarch ();
2891 cleanup_child
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2893 uiout
->field_core_addr ("address", gdbarch
, r
->start
);
2894 uiout
->field_int ("length", r
->length
);
2896 data
= (gdb_byte
*) xmalloc (r
->length
);
2897 make_cleanup (xfree
, data
);
2899 if (memory_contents
)
2901 if (target_read_memory (r
->start
, data
, r
->length
) == 0)
2906 data_str
= (char *) xmalloc (r
->length
* 2 + 1);
2907 make_cleanup (xfree
, data_str
);
2909 for (m
= 0, p
= data_str
; m
< r
->length
; ++m
, p
+= 2)
2910 sprintf (p
, "%02x", data
[m
]);
2911 uiout
->field_string ("contents", data_str
);
2914 uiout
->field_skip ("contents");
2916 do_cleanups (cleanup_child
);
2919 do_cleanups (list_cleanup
);
2924 _initialize_mi_main (void)
2926 struct cmd_list_element
*c
;
2928 add_setshow_boolean_cmd ("mi-async", class_run
,
2930 Set whether MI asynchronous mode is enabled."), _("\
2931 Show whether MI asynchronous mode is enabled."), _("\
2932 Tells GDB whether MI should be in asynchronous mode."),
2933 set_mi_async_command
,
2934 show_mi_async_command
,
2938 /* Alias old "target-async" to "mi-async". */
2939 c
= add_alias_cmd ("target-async", "mi-async", class_run
, 0, &setlist
);
2940 deprecate_cmd (c
, "set mi-async");
2941 c
= add_alias_cmd ("target-async", "mi-async", class_run
, 0, &showlist
);
2942 deprecate_cmd (c
, "show mi-async");