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"
62 #include "progspace-and-thread.h"
71 /* This is used to pass the current command timestamp down to
72 continuation routines. */
73 static struct mi_timestamp
*current_command_ts
;
75 static int do_timings
= 0;
78 /* Few commands would like to know if options like --thread-group were
79 explicitly specified. This variable keeps the current parsed
80 command including all option, and make it possible. */
81 static struct mi_parse
*current_context
;
83 int running_result_record_printed
= 1;
85 /* Flag indicating that the target has proceeded since the last
86 command was issued. */
89 extern void _initialize_mi_main (void);
90 static void mi_cmd_execute (struct mi_parse
*parse
);
92 static void mi_execute_cli_command (const char *cmd
, int args_p
,
94 static void mi_execute_async_cli_command (const char *cli_command
,
95 char **argv
, int argc
);
96 static int register_changed_p (int regnum
, struct regcache
*,
98 static void output_register (struct frame_info
*, int regnum
, int format
,
99 int skip_unavailable
);
101 /* Controls whether the frontend wants MI in async mode. */
102 static int mi_async
= 0;
104 /* The set command writes to this variable. If the inferior is
105 executing, mi_async is *not* updated. */
106 static int mi_async_1
= 0;
109 set_mi_async_command (char *args
, int from_tty
,
110 struct cmd_list_element
*c
)
112 if (have_live_inferiors ())
114 mi_async_1
= mi_async
;
115 error (_("Cannot change this setting while the inferior is running."));
118 mi_async
= mi_async_1
;
122 show_mi_async_command (struct ui_file
*file
, int from_tty
,
123 struct cmd_list_element
*c
,
126 fprintf_filtered (file
,
127 _("Whether MI is in asynchronous mode is %s.\n"),
131 /* A wrapper for target_can_async_p that takes the MI setting into
137 return mi_async
&& target_can_async_p ();
140 /* Command implementations. FIXME: Is this libgdb? No. This is the MI
141 layer that calls libgdb. Any operation used in the below should be
144 static void timestamp (struct mi_timestamp
*tv
);
146 static void print_diff (struct ui_file
*file
, struct mi_timestamp
*start
,
147 struct mi_timestamp
*end
);
150 mi_cmd_gdb_exit (const char *command
, char **argv
, int argc
)
152 struct mi_interp
*mi
= (struct mi_interp
*) current_interpreter ();
154 /* We have to print everything right here because we never return. */
156 fputs_unfiltered (current_token
, mi
->raw_stdout
);
157 fputs_unfiltered ("^exit\n", mi
->raw_stdout
);
158 mi_out_put (current_uiout
, mi
->raw_stdout
);
159 gdb_flush (mi
->raw_stdout
);
160 /* FIXME: The function called is not yet a formal libgdb function. */
161 quit_force (NULL
, FROM_TTY
);
165 mi_cmd_exec_next (const char *command
, char **argv
, int argc
)
167 /* FIXME: Should call a libgdb function, not a cli wrapper. */
168 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
169 mi_execute_async_cli_command ("reverse-next", argv
+ 1, argc
- 1);
171 mi_execute_async_cli_command ("next", argv
, argc
);
175 mi_cmd_exec_next_instruction (const char *command
, char **argv
, int argc
)
177 /* FIXME: Should call a libgdb function, not a cli wrapper. */
178 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
179 mi_execute_async_cli_command ("reverse-nexti", argv
+ 1, argc
- 1);
181 mi_execute_async_cli_command ("nexti", argv
, argc
);
185 mi_cmd_exec_step (const char *command
, char **argv
, int argc
)
187 /* FIXME: Should call a libgdb function, not a cli wrapper. */
188 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
189 mi_execute_async_cli_command ("reverse-step", argv
+ 1, argc
- 1);
191 mi_execute_async_cli_command ("step", argv
, argc
);
195 mi_cmd_exec_step_instruction (const char *command
, char **argv
, int argc
)
197 /* FIXME: Should call a libgdb function, not a cli wrapper. */
198 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
199 mi_execute_async_cli_command ("reverse-stepi", argv
+ 1, argc
- 1);
201 mi_execute_async_cli_command ("stepi", argv
, argc
);
205 mi_cmd_exec_finish (const char *command
, char **argv
, int argc
)
207 /* FIXME: Should call a libgdb function, not a cli wrapper. */
208 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
209 mi_execute_async_cli_command ("reverse-finish", argv
+ 1, argc
- 1);
211 mi_execute_async_cli_command ("finish", argv
, argc
);
215 mi_cmd_exec_return (const char *command
, char **argv
, int argc
)
217 /* This command doesn't really execute the target, it just pops the
218 specified number of frames. */
220 /* Call return_command with from_tty argument equal to 0 so as to
221 avoid being queried. */
222 return_command (*argv
, 0);
224 /* Call return_command with from_tty argument equal to 0 so as to
225 avoid being queried. */
226 return_command (NULL
, 0);
228 /* Because we have called return_command with from_tty = 0, we need
229 to print the frame here. */
230 print_stack_frame (get_selected_frame (NULL
), 1, LOC_AND_ADDRESS
, 1);
234 mi_cmd_exec_jump (const char *args
, char **argv
, int argc
)
236 /* FIXME: Should call a libgdb function, not a cli wrapper. */
237 mi_execute_async_cli_command ("jump", argv
, argc
);
241 proceed_thread (struct thread_info
*thread
, int pid
)
243 if (!is_stopped (thread
->ptid
))
246 if (pid
!= 0 && ptid_get_pid (thread
->ptid
) != pid
)
249 switch_to_thread (thread
->ptid
);
250 clear_proceed_status (0);
251 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
);
255 proceed_thread_callback (struct thread_info
*thread
, void *arg
)
257 int pid
= *(int *)arg
;
259 proceed_thread (thread
, pid
);
264 exec_continue (char **argv
, int argc
)
266 prepare_execution_command (¤t_target
, mi_async_p ());
270 /* In non-stop mode, 'resume' always resumes a single thread.
271 Therefore, to resume all threads of the current inferior, or
272 all threads in all inferiors, we need to iterate over
275 See comment on infcmd.c:proceed_thread_callback for rationale. */
276 if (current_context
->all
|| current_context
->thread_group
!= -1)
278 scoped_restore_current_thread restore_thread
;
281 if (!current_context
->all
)
284 = find_inferior_id (current_context
->thread_group
);
288 iterate_over_threads (proceed_thread_callback
, &pid
);
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 scoped_restore_current_pspace_and_thread restore_pspace_thread
;
473 iterate_over_inferiors (run_one_inferior
, &start_p
);
477 const char *run_cmd
= start_p
? "start" : "run";
478 struct target_ops
*run_target
= find_run_target ();
479 int async_p
= mi_async
&& run_target
->to_can_async_p (run_target
);
481 mi_execute_cli_command (run_cmd
, async_p
,
482 async_p
? "&" : NULL
);
488 find_thread_of_process (struct thread_info
*ti
, void *p
)
492 if (ptid_get_pid (ti
->ptid
) == pid
&& !is_exited (ti
->ptid
))
499 mi_cmd_target_detach (const char *command
, char **argv
, int argc
)
501 if (argc
!= 0 && argc
!= 1)
502 error (_("Usage: -target-detach [pid | thread-group]"));
506 struct thread_info
*tp
;
510 /* First see if we are dealing with a thread-group id. */
513 struct inferior
*inf
;
514 int id
= strtoul (argv
[0] + 1, &end
, 0);
517 error (_("Invalid syntax of thread-group id '%s'"), argv
[0]);
519 inf
= find_inferior_id (id
);
521 error (_("Non-existent thread-group id '%d'"), id
);
527 /* We must be dealing with a pid. */
528 pid
= strtol (argv
[0], &end
, 10);
531 error (_("Invalid identifier '%s'"), argv
[0]);
534 /* Pick any thread in the desired process. Current
535 target_detach detaches from the parent of inferior_ptid. */
536 tp
= iterate_over_threads (find_thread_of_process
, &pid
);
538 error (_("Thread group is empty"));
540 switch_to_thread (tp
->ptid
);
543 detach_command (NULL
, 0);
547 mi_cmd_target_flash_erase (const char *command
, char **argv
, int argc
)
549 flash_erase_command (NULL
, 0);
553 mi_cmd_thread_select (const char *command
, char **argv
, int argc
)
556 char *mi_error_message
;
557 ptid_t previous_ptid
= inferior_ptid
;
560 error (_("-thread-select: USAGE: threadnum."));
562 rc
= gdb_thread_select (current_uiout
, argv
[0], &mi_error_message
);
564 /* If thread switch did not succeed don't notify or print. */
565 if (rc
== GDB_RC_FAIL
)
567 make_cleanup (xfree
, mi_error_message
);
568 error ("%s", mi_error_message
);
571 print_selected_thread_frame (current_uiout
,
572 USER_SELECTED_THREAD
| USER_SELECTED_FRAME
);
574 /* Notify if the thread has effectively changed. */
575 if (!ptid_equal (inferior_ptid
, previous_ptid
))
577 observer_notify_user_selected_context_changed (USER_SELECTED_THREAD
578 | USER_SELECTED_FRAME
);
583 mi_cmd_thread_list_ids (const char *command
, char **argv
, int argc
)
586 char *mi_error_message
;
589 error (_("-thread-list-ids: No arguments required."));
591 rc
= gdb_list_thread_ids (current_uiout
, &mi_error_message
);
593 if (rc
== GDB_RC_FAIL
)
595 make_cleanup (xfree
, mi_error_message
);
596 error ("%s", mi_error_message
);
601 mi_cmd_thread_info (const char *command
, char **argv
, int argc
)
603 if (argc
!= 0 && argc
!= 1)
604 error (_("Invalid MI command"));
606 print_thread_info (current_uiout
, argv
[0], -1);
609 struct collect_cores_data
617 collect_cores (struct thread_info
*ti
, void *xdata
)
619 struct collect_cores_data
*data
= (struct collect_cores_data
*) xdata
;
621 if (ptid_get_pid (ti
->ptid
) == data
->pid
)
623 int core
= target_core_of_thread (ti
->ptid
);
626 VEC_safe_push (int, data
->cores
, core
);
633 unique (int *b
, int *e
)
643 struct print_one_inferior_data
646 VEC (int) *inferiors
;
650 print_one_inferior (struct inferior
*inferior
, void *xdata
)
652 struct print_one_inferior_data
*top_data
653 = (struct print_one_inferior_data
*) xdata
;
654 struct ui_out
*uiout
= current_uiout
;
656 if (VEC_empty (int, top_data
->inferiors
)
657 || bsearch (&(inferior
->pid
), VEC_address (int, top_data
->inferiors
),
658 VEC_length (int, top_data
->inferiors
), sizeof (int),
659 compare_positive_ints
))
661 struct collect_cores_data data
;
662 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
664 uiout
->field_fmt ("id", "i%d", inferior
->num
);
665 uiout
->field_string ("type", "process");
666 if (inferior
->has_exit_code
)
667 uiout
->field_string ("exit-code",
668 int_string (inferior
->exit_code
, 8, 0, 0, 1));
669 if (inferior
->pid
!= 0)
670 uiout
->field_int ("pid", inferior
->pid
);
672 if (inferior
->pspace
->pspace_exec_filename
!= NULL
)
674 uiout
->field_string ("executable",
675 inferior
->pspace
->pspace_exec_filename
);
679 if (inferior
->pid
!= 0)
681 data
.pid
= inferior
->pid
;
682 iterate_over_threads (collect_cores
, &data
);
685 if (!VEC_empty (int, data
.cores
))
688 ui_out_emit_list
list_emitter (uiout
, "cores");
690 qsort (VEC_address (int, data
.cores
),
691 VEC_length (int, data
.cores
), sizeof (int),
692 compare_positive_ints
);
694 b
= VEC_address (int, data
.cores
);
695 e
= b
+ VEC_length (int, data
.cores
);
699 uiout
->field_int (NULL
, *b
);
702 if (top_data
->recurse
)
703 print_thread_info (uiout
, NULL
, inferior
->pid
);
709 /* Output a field named 'cores' with a list as the value. The
710 elements of the list are obtained by splitting 'cores' on
714 output_cores (struct ui_out
*uiout
, const char *field_name
, const char *xcores
)
716 struct cleanup
*back_to
= make_cleanup_ui_out_list_begin_end (uiout
,
718 char *cores
= xstrdup (xcores
);
721 make_cleanup (xfree
, cores
);
723 for (p
= strtok (p
, ","); p
; p
= strtok (NULL
, ","))
724 uiout
->field_string (NULL
, p
);
726 do_cleanups (back_to
);
730 free_vector_of_ints (void *xvector
)
732 VEC (int) **vector
= (VEC (int) **) xvector
;
734 VEC_free (int, *vector
);
738 do_nothing (splay_tree_key k
)
743 free_vector_of_osdata_items (splay_tree_value xvalue
)
745 VEC (osdata_item_s
) *value
= (VEC (osdata_item_s
) *) xvalue
;
747 /* We don't free the items itself, it will be done separately. */
748 VEC_free (osdata_item_s
, value
);
752 splay_tree_int_comparator (splay_tree_key xa
, splay_tree_key xb
)
761 free_splay_tree (void *xt
)
763 splay_tree t
= (splay_tree
) xt
;
764 splay_tree_delete (t
);
768 list_available_thread_groups (VEC (int) *ids
, int recurse
)
771 struct osdata_item
*item
;
773 struct ui_out
*uiout
= current_uiout
;
774 struct cleanup
*cleanup
;
776 /* This keeps a map from integer (pid) to VEC (struct osdata_item *)*
777 The vector contains information about all threads for the given pid.
778 This is assigned an initial value to avoid "may be used uninitialized"
780 splay_tree tree
= NULL
;
782 /* get_osdata will throw if it cannot return data. */
783 data
= get_osdata ("processes");
784 cleanup
= make_cleanup_osdata_free (data
);
788 struct osdata
*threads
= get_osdata ("threads");
790 make_cleanup_osdata_free (threads
);
791 tree
= splay_tree_new (splay_tree_int_comparator
,
793 free_vector_of_osdata_items
);
794 make_cleanup (free_splay_tree
, tree
);
797 VEC_iterate (osdata_item_s
, threads
->items
,
801 const char *pid
= get_osdata_column (item
, "pid");
802 int pid_i
= strtoul (pid
, NULL
, 0);
803 VEC (osdata_item_s
) *vec
= 0;
805 splay_tree_node n
= splay_tree_lookup (tree
, pid_i
);
808 VEC_safe_push (osdata_item_s
, vec
, item
);
809 splay_tree_insert (tree
, pid_i
, (splay_tree_value
)vec
);
813 vec
= (VEC (osdata_item_s
) *) n
->value
;
814 VEC_safe_push (osdata_item_s
, vec
, item
);
815 n
->value
= (splay_tree_value
) vec
;
820 make_cleanup_ui_out_list_begin_end (uiout
, "groups");
823 VEC_iterate (osdata_item_s
, data
->items
,
827 const char *pid
= get_osdata_column (item
, "pid");
828 const char *cmd
= get_osdata_column (item
, "command");
829 const char *user
= get_osdata_column (item
, "user");
830 const char *cores
= get_osdata_column (item
, "cores");
832 int pid_i
= strtoul (pid
, NULL
, 0);
834 /* At present, the target will return all available processes
835 and if information about specific ones was required, we filter
836 undesired processes here. */
837 if (ids
&& bsearch (&pid_i
, VEC_address (int, ids
),
838 VEC_length (int, ids
),
839 sizeof (int), compare_positive_ints
) == NULL
)
843 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
845 uiout
->field_fmt ("id", "%s", pid
);
846 uiout
->field_string ("type", "process");
848 uiout
->field_string ("description", cmd
);
850 uiout
->field_string ("user", user
);
852 output_cores (uiout
, "cores", cores
);
856 splay_tree_node n
= splay_tree_lookup (tree
, pid_i
);
859 VEC (osdata_item_s
) *children
= (VEC (osdata_item_s
) *) n
->value
;
860 struct osdata_item
*child
;
863 make_cleanup_ui_out_list_begin_end (uiout
, "threads");
866 VEC_iterate (osdata_item_s
, children
, ix_child
, child
);
869 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
870 const char *tid
= get_osdata_column (child
, "tid");
871 const char *tcore
= get_osdata_column (child
, "core");
873 uiout
->field_string ("id", tid
);
875 uiout
->field_string ("core", tcore
);
881 do_cleanups (cleanup
);
885 mi_cmd_list_thread_groups (const char *command
, char **argv
, int argc
)
887 struct ui_out
*uiout
= current_uiout
;
888 struct cleanup
*back_to
;
895 AVAILABLE_OPT
, RECURSE_OPT
897 static const struct mi_opt opts
[] =
899 {"-available", AVAILABLE_OPT
, 0},
900 {"-recurse", RECURSE_OPT
, 1},
909 int opt
= mi_getopt ("-list-thread-groups", argc
, argv
, opts
,
914 switch ((enum opt
) opt
)
920 if (strcmp (oarg
, "0") == 0)
922 else if (strcmp (oarg
, "1") == 0)
925 error (_("only '0' and '1' are valid values "
926 "for the '--recurse' option"));
931 for (; oind
< argc
; ++oind
)
936 if (*(argv
[oind
]) != 'i')
937 error (_("invalid syntax of group id '%s'"), argv
[oind
]);
939 inf
= strtoul (argv
[oind
] + 1, &end
, 0);
942 error (_("invalid syntax of group id '%s'"), argv
[oind
]);
943 VEC_safe_push (int, ids
, inf
);
945 if (VEC_length (int, ids
) > 1)
946 qsort (VEC_address (int, ids
),
947 VEC_length (int, ids
),
948 sizeof (int), compare_positive_ints
);
950 back_to
= make_cleanup (free_vector_of_ints
, &ids
);
954 list_available_thread_groups (ids
, recurse
);
956 else if (VEC_length (int, ids
) == 1)
958 /* Local thread groups, single id. */
959 int id
= *VEC_address (int, ids
);
960 struct inferior
*inf
= find_inferior_id (id
);
963 error (_("Non-existent thread group id '%d'"), id
);
965 print_thread_info (uiout
, NULL
, inf
->pid
);
969 struct print_one_inferior_data data
;
971 data
.recurse
= recurse
;
972 data
.inferiors
= ids
;
974 /* Local thread groups. Either no explicit ids -- and we
975 print everything, or several explicit ids. In both cases,
976 we print more than one group, and have to use 'groups'
977 as the top-level element. */
978 make_cleanup_ui_out_list_begin_end (uiout
, "groups");
979 update_thread_list ();
980 iterate_over_inferiors (print_one_inferior
, &data
);
983 do_cleanups (back_to
);
987 mi_cmd_data_list_register_names (const char *command
, char **argv
, int argc
)
989 struct gdbarch
*gdbarch
;
990 struct ui_out
*uiout
= current_uiout
;
994 /* Note that the test for a valid register must include checking the
995 gdbarch_register_name because gdbarch_num_regs may be allocated
996 for the union of the register sets within a family of related
997 processors. In this case, some entries of gdbarch_register_name
998 will change depending upon the particular processor being
1001 gdbarch
= get_current_arch ();
1002 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1004 ui_out_emit_list
list_emitter (uiout
, "register-names");
1006 if (argc
== 0) /* No args, just do all the regs. */
1012 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1013 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1014 uiout
->field_string (NULL
, "");
1016 uiout
->field_string (NULL
, gdbarch_register_name (gdbarch
, regnum
));
1020 /* Else, list of register #s, just do listed regs. */
1021 for (i
= 0; i
< argc
; i
++)
1023 regnum
= atoi (argv
[i
]);
1024 if (regnum
< 0 || regnum
>= numregs
)
1025 error (_("bad register number"));
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
));
1036 mi_cmd_data_list_changed_registers (const char *command
, char **argv
, int argc
)
1038 static struct regcache
*this_regs
= NULL
;
1039 struct ui_out
*uiout
= current_uiout
;
1040 struct regcache
*prev_regs
;
1041 struct gdbarch
*gdbarch
;
1042 int regnum
, numregs
, changed
;
1044 struct cleanup
*cleanup
;
1046 /* The last time we visited this function, the current frame's
1047 register contents were saved in THIS_REGS. Move THIS_REGS over
1048 to PREV_REGS, and refresh THIS_REGS with the now-current register
1051 prev_regs
= this_regs
;
1052 this_regs
= frame_save_as_regcache (get_selected_frame (NULL
));
1053 cleanup
= make_cleanup_regcache_xfree (prev_regs
);
1055 /* Note that the test for a valid register must include checking the
1056 gdbarch_register_name because gdbarch_num_regs may be allocated
1057 for the union of the register sets within a family of related
1058 processors. In this case, some entries of gdbarch_register_name
1059 will change depending upon the particular processor being
1062 gdbarch
= get_regcache_arch (this_regs
);
1063 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1065 make_cleanup_ui_out_list_begin_end (uiout
, "changed-registers");
1069 /* No args, just do all the regs. */
1074 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1075 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1077 changed
= register_changed_p (regnum
, prev_regs
, this_regs
);
1079 error (_("-data-list-changed-registers: "
1080 "Unable to read register contents."));
1082 uiout
->field_int (NULL
, regnum
);
1086 /* Else, list of register #s, just do listed regs. */
1087 for (i
= 0; i
< argc
; i
++)
1089 regnum
= atoi (argv
[i
]);
1093 && gdbarch_register_name (gdbarch
, regnum
) != NULL
1094 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
1096 changed
= register_changed_p (regnum
, prev_regs
, this_regs
);
1098 error (_("-data-list-changed-registers: "
1099 "Unable to read register contents."));
1101 uiout
->field_int (NULL
, regnum
);
1104 error (_("bad register number"));
1106 do_cleanups (cleanup
);
1110 register_changed_p (int regnum
, struct regcache
*prev_regs
,
1111 struct regcache
*this_regs
)
1113 struct gdbarch
*gdbarch
= get_regcache_arch (this_regs
);
1114 struct value
*prev_value
, *this_value
;
1117 /* First time through or after gdbarch change consider all registers
1119 if (!prev_regs
|| get_regcache_arch (prev_regs
) != gdbarch
)
1122 /* Get register contents and compare. */
1123 prev_value
= prev_regs
->cooked_read_value (regnum
);
1124 this_value
= this_regs
->cooked_read_value (regnum
);
1125 gdb_assert (prev_value
!= NULL
);
1126 gdb_assert (this_value
!= NULL
);
1128 if (value_optimized_out (prev_value
) != value_optimized_out (this_value
)
1129 || value_entirely_available (prev_value
)
1130 != value_entirely_available (this_value
))
1132 if (value_optimized_out (prev_value
)
1133 || !value_entirely_available (prev_value
))
1136 ret
= memcmp (value_contents_all (prev_value
),
1137 value_contents_all (this_value
),
1138 register_size (gdbarch
, regnum
)) != 0;
1140 release_value (prev_value
);
1141 release_value (this_value
);
1142 value_free (prev_value
);
1143 value_free (this_value
);
1147 /* Return a list of register number and value pairs. The valid
1148 arguments expected are: a letter indicating the format in which to
1149 display the registers contents. This can be one of: x
1150 (hexadecimal), d (decimal), N (natural), t (binary), o (octal), r
1151 (raw). After the format argument there can be a sequence of
1152 numbers, indicating which registers to fetch the content of. If
1153 the format is the only argument, a list of all the registers with
1154 their values is returned. */
1157 mi_cmd_data_list_register_values (const char *command
, char **argv
, int argc
)
1159 struct ui_out
*uiout
= current_uiout
;
1160 struct frame_info
*frame
;
1161 struct gdbarch
*gdbarch
;
1162 int regnum
, numregs
, format
;
1164 int skip_unavailable
= 0;
1170 static const struct mi_opt opts
[] =
1172 {"-skip-unavailable", SKIP_UNAVAILABLE
, 0},
1176 /* Note that the test for a valid register must include checking the
1177 gdbarch_register_name because gdbarch_num_regs may be allocated
1178 for the union of the register sets within a family of related
1179 processors. In this case, some entries of gdbarch_register_name
1180 will change depending upon the particular processor being
1186 int opt
= mi_getopt ("-data-list-register-values", argc
, argv
,
1187 opts
, &oind
, &oarg
);
1191 switch ((enum opt
) opt
)
1193 case SKIP_UNAVAILABLE
:
1194 skip_unavailable
= 1;
1199 if (argc
- oind
< 1)
1200 error (_("-data-list-register-values: Usage: "
1201 "-data-list-register-values [--skip-unavailable] <format>"
1202 " [<regnum1>...<regnumN>]"));
1204 format
= (int) argv
[oind
][0];
1206 frame
= get_selected_frame (NULL
);
1207 gdbarch
= get_frame_arch (frame
);
1208 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1210 ui_out_emit_list
list_emitter (uiout
, "register-values");
1212 if (argc
- oind
== 1)
1214 /* No args, beside the format: do all the regs. */
1219 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1220 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1223 output_register (frame
, regnum
, format
, skip_unavailable
);
1227 /* Else, list of register #s, just do listed regs. */
1228 for (i
= 1 + oind
; i
< argc
; i
++)
1230 regnum
= atoi (argv
[i
]);
1234 && gdbarch_register_name (gdbarch
, regnum
) != NULL
1235 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
1236 output_register (frame
, regnum
, format
, skip_unavailable
);
1238 error (_("bad register number"));
1242 /* Output one register REGNUM's contents in the desired FORMAT. If
1243 SKIP_UNAVAILABLE is true, skip the register if it is
1247 output_register (struct frame_info
*frame
, int regnum
, int format
,
1248 int skip_unavailable
)
1250 struct ui_out
*uiout
= current_uiout
;
1251 struct value
*val
= value_of_register (regnum
, frame
);
1252 struct value_print_options opts
;
1254 if (skip_unavailable
&& !value_entirely_available (val
))
1257 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1258 uiout
->field_int ("number", regnum
);
1268 get_formatted_print_options (&opts
, format
);
1270 val_print (value_type (val
),
1271 value_embedded_offset (val
), 0,
1272 &stb
, 0, val
, &opts
, current_language
);
1273 uiout
->field_stream ("value", stb
);
1276 /* Write given values into registers. The registers and values are
1277 given as pairs. The corresponding MI command is
1278 -data-write-register-values <format>
1279 [<regnum1> <value1>...<regnumN> <valueN>] */
1281 mi_cmd_data_write_register_values (const char *command
, char **argv
, int argc
)
1283 struct regcache
*regcache
;
1284 struct gdbarch
*gdbarch
;
1287 /* Note that the test for a valid register must include checking the
1288 gdbarch_register_name because gdbarch_num_regs may be allocated
1289 for the union of the register sets within a family of related
1290 processors. In this case, some entries of gdbarch_register_name
1291 will change depending upon the particular processor being
1294 regcache
= get_current_regcache ();
1295 gdbarch
= get_regcache_arch (regcache
);
1296 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1299 error (_("-data-write-register-values: Usage: -data-write-register-"
1300 "values <format> [<regnum1> <value1>...<regnumN> <valueN>]"));
1302 if (!target_has_registers
)
1303 error (_("-data-write-register-values: No registers."));
1306 error (_("-data-write-register-values: No regs and values specified."));
1309 error (_("-data-write-register-values: "
1310 "Regs and vals are not in pairs."));
1312 for (i
= 1; i
< argc
; i
= i
+ 2)
1314 int regnum
= atoi (argv
[i
]);
1316 if (regnum
>= 0 && regnum
< numregs
1317 && gdbarch_register_name (gdbarch
, regnum
)
1318 && *gdbarch_register_name (gdbarch
, regnum
))
1322 /* Get the value as a number. */
1323 value
= parse_and_eval_address (argv
[i
+ 1]);
1325 /* Write it down. */
1326 regcache_cooked_write_signed (regcache
, regnum
, value
);
1329 error (_("bad register number"));
1333 /* Evaluate the value of the argument. The argument is an
1334 expression. If the expression contains spaces it needs to be
1335 included in double quotes. */
1338 mi_cmd_data_evaluate_expression (const char *command
, char **argv
, int argc
)
1341 struct value_print_options opts
;
1342 struct ui_out
*uiout
= current_uiout
;
1345 error (_("-data-evaluate-expression: "
1346 "Usage: -data-evaluate-expression expression"));
1348 expression_up expr
= parse_expression (argv
[0]);
1350 val
= evaluate_expression (expr
.get ());
1354 /* Print the result of the expression evaluation. */
1355 get_user_print_options (&opts
);
1357 common_val_print (val
, &stb
, 0, &opts
, current_language
);
1359 uiout
->field_stream ("value", stb
);
1362 /* This is the -data-read-memory command.
1364 ADDR: start address of data to be dumped.
1365 WORD-FORMAT: a char indicating format for the ``word''. See
1367 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
1368 NR_ROW: Number of rows.
1369 NR_COL: The number of colums (words per row).
1370 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
1371 ASCHAR for unprintable characters.
1373 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
1374 displayes them. Returns:
1376 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
1379 The number of bytes read is SIZE*ROW*COL. */
1382 mi_cmd_data_read_memory (const char *command
, char **argv
, int argc
)
1384 struct gdbarch
*gdbarch
= get_current_arch ();
1385 struct ui_out
*uiout
= current_uiout
;
1387 long total_bytes
, nr_cols
, nr_rows
;
1389 struct type
*word_type
;
1401 static const struct mi_opt opts
[] =
1403 {"o", OFFSET_OPT
, 1},
1409 int opt
= mi_getopt ("-data-read-memory", argc
, argv
, opts
,
1414 switch ((enum opt
) opt
)
1417 offset
= atol (oarg
);
1424 if (argc
< 5 || argc
> 6)
1425 error (_("-data-read-memory: Usage: "
1426 "ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR]."));
1428 /* Extract all the arguments. */
1430 /* Start address of the memory dump. */
1431 addr
= parse_and_eval_address (argv
[0]) + offset
;
1432 /* The format character to use when displaying a memory word. See
1433 the ``x'' command. */
1434 word_format
= argv
[1][0];
1435 /* The size of the memory word. */
1436 word_size
= atol (argv
[2]);
1440 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1444 word_type
= builtin_type (gdbarch
)->builtin_int16
;
1448 word_type
= builtin_type (gdbarch
)->builtin_int32
;
1452 word_type
= builtin_type (gdbarch
)->builtin_int64
;
1456 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1459 /* The number of rows. */
1460 nr_rows
= atol (argv
[3]);
1462 error (_("-data-read-memory: invalid number of rows."));
1464 /* Number of bytes per row. */
1465 nr_cols
= atol (argv
[4]);
1467 error (_("-data-read-memory: invalid number of columns."));
1469 /* The un-printable character when printing ascii. */
1475 /* Create a buffer and read it in. */
1476 total_bytes
= word_size
* nr_rows
* nr_cols
;
1478 std::unique_ptr
<gdb_byte
[]> mbuf (new gdb_byte
[total_bytes
]);
1480 /* Dispatch memory reads to the topmost target, not the flattened
1482 nr_bytes
= target_read (current_target
.beneath
,
1483 TARGET_OBJECT_MEMORY
, NULL
, mbuf
.get (),
1486 error (_("Unable to read memory."));
1488 /* Output the header information. */
1489 uiout
->field_core_addr ("addr", gdbarch
, addr
);
1490 uiout
->field_int ("nr-bytes", nr_bytes
);
1491 uiout
->field_int ("total-bytes", total_bytes
);
1492 uiout
->field_core_addr ("next-row", gdbarch
, addr
+ word_size
* nr_cols
);
1493 uiout
->field_core_addr ("prev-row", gdbarch
, addr
- word_size
* nr_cols
);
1494 uiout
->field_core_addr ("next-page", gdbarch
, addr
+ total_bytes
);
1495 uiout
->field_core_addr ("prev-page", gdbarch
, addr
- total_bytes
);
1497 /* Build the result as a two dimentional table. */
1501 struct cleanup
*cleanup_list
;
1505 cleanup_list
= make_cleanup_ui_out_list_begin_end (uiout
, "memory");
1506 for (row
= 0, row_byte
= 0;
1508 row
++, row_byte
+= nr_cols
* word_size
)
1512 struct cleanup
*cleanup_list_data
;
1513 struct value_print_options opts
;
1515 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1516 uiout
->field_core_addr ("addr", gdbarch
, addr
+ row_byte
);
1517 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr +
1519 cleanup_list_data
= make_cleanup_ui_out_list_begin_end (uiout
, "data");
1520 get_formatted_print_options (&opts
, word_format
);
1521 for (col
= 0, col_byte
= row_byte
;
1523 col
++, col_byte
+= word_size
)
1525 if (col_byte
+ word_size
> nr_bytes
)
1527 uiout
->field_string (NULL
, "N/A");
1532 print_scalar_formatted (&mbuf
[col_byte
], word_type
, &opts
,
1533 word_asize
, &stream
);
1534 uiout
->field_stream (NULL
, stream
);
1537 do_cleanups (cleanup_list_data
);
1543 for (byte
= row_byte
;
1544 byte
< row_byte
+ word_size
* nr_cols
; byte
++)
1546 if (byte
>= nr_bytes
)
1548 else if (mbuf
[byte
] < 32 || mbuf
[byte
] > 126)
1549 stream
.putc (aschar
);
1551 stream
.putc (mbuf
[byte
]);
1553 uiout
->field_stream ("ascii", stream
);
1556 do_cleanups (cleanup_list
);
1561 mi_cmd_data_read_memory_bytes (const char *command
, char **argv
, int argc
)
1563 struct gdbarch
*gdbarch
= get_current_arch ();
1564 struct ui_out
*uiout
= current_uiout
;
1565 struct cleanup
*cleanups
;
1568 memory_read_result_s
*read_result
;
1570 VEC(memory_read_result_s
) *result
;
1572 int unit_size
= gdbarch_addressable_memory_unit_size (gdbarch
);
1579 static const struct mi_opt opts
[] =
1581 {"o", OFFSET_OPT
, 1},
1587 int opt
= mi_getopt ("-data-read-memory-bytes", argc
, argv
, opts
,
1591 switch ((enum opt
) opt
)
1594 offset
= atol (oarg
);
1602 error (_("Usage: [ -o OFFSET ] ADDR LENGTH."));
1604 addr
= parse_and_eval_address (argv
[0]) + offset
;
1605 length
= atol (argv
[1]);
1607 result
= read_memory_robust (current_target
.beneath
, addr
, length
);
1609 cleanups
= make_cleanup (free_memory_read_result_vector
, &result
);
1611 if (VEC_length (memory_read_result_s
, result
) == 0)
1612 error (_("Unable to read memory."));
1614 make_cleanup_ui_out_list_begin_end (uiout
, "memory");
1616 VEC_iterate (memory_read_result_s
, result
, ix
, read_result
);
1619 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
1624 uiout
->field_core_addr ("begin", gdbarch
, read_result
->begin
);
1625 uiout
->field_core_addr ("offset", gdbarch
, read_result
->begin
- addr
);
1626 uiout
->field_core_addr ("end", gdbarch
, read_result
->end
);
1628 alloc_len
= (read_result
->end
- read_result
->begin
) * 2 * unit_size
+ 1;
1629 data
= (char *) xmalloc (alloc_len
);
1631 for (i
= 0, p
= data
;
1632 i
< ((read_result
->end
- read_result
->begin
) * unit_size
);
1635 sprintf (p
, "%02x", read_result
->data
[i
]);
1637 uiout
->field_string ("contents", data
);
1640 do_cleanups (cleanups
);
1643 /* Implementation of the -data-write_memory command.
1645 COLUMN_OFFSET: optional argument. Must be preceded by '-o'. The
1646 offset from the beginning of the memory grid row where the cell to
1648 ADDR: start address of the row in the memory grid where the memory
1649 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
1650 the location to write to.
1651 FORMAT: a char indicating format for the ``word''. See
1653 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
1654 VALUE: value to be written into the memory address.
1656 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1661 mi_cmd_data_write_memory (const char *command
, char **argv
, int argc
)
1663 struct gdbarch
*gdbarch
= get_current_arch ();
1664 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1667 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1668 enough when using a compiler other than GCC. */
1671 struct cleanup
*old_chain
;
1679 static const struct mi_opt opts
[] =
1681 {"o", OFFSET_OPT
, 1},
1687 int opt
= mi_getopt ("-data-write-memory", argc
, argv
, opts
,
1692 switch ((enum opt
) opt
)
1695 offset
= atol (oarg
);
1703 error (_("-data-write-memory: Usage: "
1704 "[-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE."));
1706 /* Extract all the arguments. */
1707 /* Start address of the memory dump. */
1708 addr
= parse_and_eval_address (argv
[0]);
1709 /* The size of the memory word. */
1710 word_size
= atol (argv
[2]);
1712 /* Calculate the real address of the write destination. */
1713 addr
+= (offset
* word_size
);
1715 /* Get the value as a number. */
1716 value
= parse_and_eval_address (argv
[3]);
1717 /* Get the value into an array. */
1718 buffer
= (gdb_byte
*) xmalloc (word_size
);
1719 old_chain
= make_cleanup (xfree
, buffer
);
1720 store_signed_integer (buffer
, word_size
, byte_order
, value
);
1721 /* Write it down to memory. */
1722 write_memory_with_notification (addr
, buffer
, word_size
);
1723 /* Free the buffer. */
1724 do_cleanups (old_chain
);
1727 /* Implementation of the -data-write-memory-bytes command.
1730 DATA: string of bytes to write at that address
1731 COUNT: number of bytes to be filled (decimal integer). */
1734 mi_cmd_data_write_memory_bytes (const char *command
, char **argv
, int argc
)
1740 size_t len_hex
, len_bytes
, len_units
, i
, steps
, remaining_units
;
1741 long int count_units
;
1742 struct cleanup
*back_to
;
1745 if (argc
!= 2 && argc
!= 3)
1746 error (_("Usage: ADDR DATA [COUNT]."));
1748 addr
= parse_and_eval_address (argv
[0]);
1750 len_hex
= strlen (cdata
);
1751 unit_size
= gdbarch_addressable_memory_unit_size (get_current_arch ());
1753 if (len_hex
% (unit_size
* 2) != 0)
1754 error (_("Hex-encoded '%s' must represent an integral number of "
1755 "addressable memory units."),
1758 len_bytes
= len_hex
/ 2;
1759 len_units
= len_bytes
/ unit_size
;
1762 count_units
= strtoul (argv
[2], NULL
, 10);
1764 count_units
= len_units
;
1766 databuf
= XNEWVEC (gdb_byte
, len_bytes
);
1767 back_to
= make_cleanup (xfree
, databuf
);
1769 for (i
= 0; i
< len_bytes
; ++i
)
1772 if (sscanf (cdata
+ i
* 2, "%02x", &x
) != 1)
1773 error (_("Invalid argument"));
1774 databuf
[i
] = (gdb_byte
) x
;
1777 if (len_units
< count_units
)
1779 /* Pattern is made of less units than count:
1780 repeat pattern to fill memory. */
1781 data
= (gdb_byte
*) xmalloc (count_units
* unit_size
);
1782 make_cleanup (xfree
, data
);
1784 /* Number of times the pattern is entirely repeated. */
1785 steps
= count_units
/ len_units
;
1786 /* Number of remaining addressable memory units. */
1787 remaining_units
= count_units
% len_units
;
1788 for (i
= 0; i
< steps
; i
++)
1789 memcpy (data
+ i
* len_bytes
, databuf
, len_bytes
);
1791 if (remaining_units
> 0)
1792 memcpy (data
+ steps
* len_bytes
, databuf
,
1793 remaining_units
* unit_size
);
1797 /* Pattern is longer than or equal to count:
1798 just copy count addressable memory units. */
1802 write_memory_with_notification (addr
, data
, count_units
);
1804 do_cleanups (back_to
);
1808 mi_cmd_enable_timings (const char *command
, char **argv
, int argc
)
1814 if (strcmp (argv
[0], "yes") == 0)
1816 else if (strcmp (argv
[0], "no") == 0)
1827 error (_("-enable-timings: Usage: %s {yes|no}"), command
);
1831 mi_cmd_list_features (const char *command
, char **argv
, int argc
)
1835 struct ui_out
*uiout
= current_uiout
;
1837 ui_out_emit_list
list_emitter (uiout
, "features");
1838 uiout
->field_string (NULL
, "frozen-varobjs");
1839 uiout
->field_string (NULL
, "pending-breakpoints");
1840 uiout
->field_string (NULL
, "thread-info");
1841 uiout
->field_string (NULL
, "data-read-memory-bytes");
1842 uiout
->field_string (NULL
, "breakpoint-notifications");
1843 uiout
->field_string (NULL
, "ada-task-info");
1844 uiout
->field_string (NULL
, "language-option");
1845 uiout
->field_string (NULL
, "info-gdb-mi-command");
1846 uiout
->field_string (NULL
, "undefined-command-error-code");
1847 uiout
->field_string (NULL
, "exec-run-start-option");
1849 if (ext_lang_initialized_p (get_ext_lang_defn (EXT_LANG_PYTHON
)))
1850 uiout
->field_string (NULL
, "python");
1855 error (_("-list-features should be passed no arguments"));
1859 mi_cmd_list_target_features (const char *command
, char **argv
, int argc
)
1863 struct ui_out
*uiout
= current_uiout
;
1865 ui_out_emit_list
list_emitter (uiout
, "features");
1867 uiout
->field_string (NULL
, "async");
1868 if (target_can_execute_reverse
)
1869 uiout
->field_string (NULL
, "reverse");
1873 error (_("-list-target-features should be passed no arguments"));
1877 mi_cmd_add_inferior (const char *command
, char **argv
, int argc
)
1879 struct inferior
*inf
;
1882 error (_("-add-inferior should be passed no arguments"));
1884 inf
= add_inferior_with_spaces ();
1886 current_uiout
->field_fmt ("inferior", "i%d", inf
->num
);
1889 /* Callback used to find the first inferior other than the current
1893 get_other_inferior (struct inferior
*inf
, void *arg
)
1895 if (inf
== current_inferior ())
1902 mi_cmd_remove_inferior (const char *command
, char **argv
, int argc
)
1905 struct inferior
*inf
;
1908 error (_("-remove-inferior should be passed a single argument"));
1910 if (sscanf (argv
[0], "i%d", &id
) != 1)
1911 error (_("the thread group id is syntactically invalid"));
1913 inf
= find_inferior_id (id
);
1915 error (_("the specified thread group does not exist"));
1918 error (_("cannot remove an active inferior"));
1920 if (inf
== current_inferior ())
1922 struct thread_info
*tp
= 0;
1923 struct inferior
*new_inferior
1924 = iterate_over_inferiors (get_other_inferior
, NULL
);
1926 if (new_inferior
== NULL
)
1927 error (_("Cannot remove last inferior"));
1929 set_current_inferior (new_inferior
);
1930 if (new_inferior
->pid
!= 0)
1931 tp
= any_thread_of_process (new_inferior
->pid
);
1932 switch_to_thread (tp
? tp
->ptid
: null_ptid
);
1933 set_current_program_space (new_inferior
->pspace
);
1936 delete_inferior (inf
);
1941 /* Execute a command within a safe environment.
1942 Return <0 for error; >=0 for ok.
1944 args->action will tell mi_execute_command what action
1945 to perfrom after the given command has executed (display/suppress
1946 prompt, display error). */
1949 captured_mi_execute_command (struct ui_out
*uiout
, struct mi_parse
*context
)
1951 struct mi_interp
*mi
= (struct mi_interp
*) command_interp ();
1952 struct cleanup
*cleanup
;
1955 current_command_ts
= context
->cmd_start
;
1957 current_token
= xstrdup (context
->token
);
1958 cleanup
= make_cleanup (free_current_contents
, ¤t_token
);
1960 running_result_record_printed
= 0;
1962 switch (context
->op
)
1965 /* A MI command was read from the input stream. */
1967 /* FIXME: gdb_???? */
1968 fprintf_unfiltered (mi
->raw_stdout
,
1969 " token=`%s' command=`%s' args=`%s'\n",
1970 context
->token
, context
->command
, context
->args
);
1972 mi_cmd_execute (context
);
1974 /* Print the result if there were no errors.
1976 Remember that on the way out of executing a command, you have
1977 to directly use the mi_interp's uiout, since the command
1978 could have reset the interpreter, in which case the current
1979 uiout will most likely crash in the mi_out_* routines. */
1980 if (!running_result_record_printed
)
1982 fputs_unfiltered (context
->token
, mi
->raw_stdout
);
1983 /* There's no particularly good reason why target-connect results
1984 in not ^done. Should kill ^connected for MI3. */
1985 fputs_unfiltered (strcmp (context
->command
, "target-select") == 0
1986 ? "^connected" : "^done", mi
->raw_stdout
);
1987 mi_out_put (uiout
, mi
->raw_stdout
);
1988 mi_out_rewind (uiout
);
1989 mi_print_timing_maybe (mi
->raw_stdout
);
1990 fputs_unfiltered ("\n", mi
->raw_stdout
);
1993 /* The command does not want anything to be printed. In that
1994 case, the command probably should not have written anything
1995 to uiout, but in case it has written something, discard it. */
1996 mi_out_rewind (uiout
);
2003 /* A CLI command was read from the input stream. */
2004 /* This "feature" will be removed as soon as we have a
2005 complete set of mi commands. */
2006 /* Echo the command on the console. */
2007 fprintf_unfiltered (gdb_stdlog
, "%s\n", context
->command
);
2008 /* Call the "console" interpreter. */
2009 argv
[0] = (char *) INTERP_CONSOLE
;
2010 argv
[1] = context
->command
;
2011 mi_cmd_interpreter_exec ("-interpreter-exec", argv
, 2);
2013 /* If we changed interpreters, DON'T print out anything. */
2014 if (current_interp_named_p (INTERP_MI
)
2015 || current_interp_named_p (INTERP_MI1
)
2016 || current_interp_named_p (INTERP_MI2
)
2017 || current_interp_named_p (INTERP_MI3
))
2019 if (!running_result_record_printed
)
2021 fputs_unfiltered (context
->token
, mi
->raw_stdout
);
2022 fputs_unfiltered ("^done", mi
->raw_stdout
);
2023 mi_out_put (uiout
, mi
->raw_stdout
);
2024 mi_out_rewind (uiout
);
2025 mi_print_timing_maybe (mi
->raw_stdout
);
2026 fputs_unfiltered ("\n", mi
->raw_stdout
);
2029 mi_out_rewind (uiout
);
2035 do_cleanups (cleanup
);
2038 /* Print a gdb exception to the MI output stream. */
2041 mi_print_exception (const char *token
, struct gdb_exception exception
)
2043 struct mi_interp
*mi
= (struct mi_interp
*) current_interpreter ();
2045 fputs_unfiltered (token
, mi
->raw_stdout
);
2046 fputs_unfiltered ("^error,msg=\"", mi
->raw_stdout
);
2047 if (exception
.message
== NULL
)
2048 fputs_unfiltered ("unknown error", mi
->raw_stdout
);
2050 fputstr_unfiltered (exception
.message
, '"', mi
->raw_stdout
);
2051 fputs_unfiltered ("\"", mi
->raw_stdout
);
2053 switch (exception
.error
)
2055 case UNDEFINED_COMMAND_ERROR
:
2056 fputs_unfiltered (",code=\"undefined-command\"", mi
->raw_stdout
);
2060 fputs_unfiltered ("\n", mi
->raw_stdout
);
2063 /* Determine whether the parsed command already notifies the
2064 user_selected_context_changed observer. */
2067 command_notifies_uscc_observer (struct mi_parse
*command
)
2069 if (command
->op
== CLI_COMMAND
)
2071 /* CLI commands "thread" and "inferior" already send it. */
2072 return (strncmp (command
->command
, "thread ", 7) == 0
2073 || strncmp (command
->command
, "inferior ", 9) == 0);
2075 else /* MI_COMMAND */
2077 if (strcmp (command
->command
, "interpreter-exec") == 0
2078 && command
->argc
> 1)
2080 /* "thread" and "inferior" again, but through -interpreter-exec. */
2081 return (strncmp (command
->argv
[1], "thread ", 7) == 0
2082 || strncmp (command
->argv
[1], "inferior ", 9) == 0);
2086 /* -thread-select already sends it. */
2087 return strcmp (command
->command
, "thread-select") == 0;
2092 mi_execute_command (const char *cmd
, int from_tty
)
2095 std::unique_ptr
<struct mi_parse
> command
;
2097 /* This is to handle EOF (^D). We just quit gdb. */
2098 /* FIXME: we should call some API function here. */
2100 quit_force (NULL
, from_tty
);
2102 target_log_command (cmd
);
2106 command
= mi_parse (cmd
, &token
);
2108 CATCH (exception
, RETURN_MASK_ALL
)
2110 mi_print_exception (token
, exception
);
2115 if (command
!= NULL
)
2117 ptid_t previous_ptid
= inferior_ptid
;
2119 gdb::optional
<scoped_restore_tmpl
<int>> restore_suppress
;
2121 if (command
->cmd
!= NULL
&& command
->cmd
->suppress_notification
!= NULL
)
2122 restore_suppress
.emplace (command
->cmd
->suppress_notification
, 1);
2124 command
->token
= token
;
2128 command
->cmd_start
= new mi_timestamp ();
2129 timestamp (command
->cmd_start
);
2134 captured_mi_execute_command (current_uiout
, command
.get ());
2136 CATCH (result
, RETURN_MASK_ALL
)
2138 /* Like in start_event_loop, enable input and force display
2139 of the prompt. Otherwise, any command that calls
2140 async_disable_stdin, and then throws, will leave input
2142 async_enable_stdin ();
2143 current_ui
->prompt_state
= PROMPT_NEEDED
;
2145 /* The command execution failed and error() was called
2147 mi_print_exception (command
->token
, result
);
2148 mi_out_rewind (current_uiout
);
2152 bpstat_do_actions ();
2154 if (/* The notifications are only output when the top-level
2155 interpreter (specified on the command line) is MI. */
2156 interp_ui_out (top_level_interpreter ())->is_mi_like_p ()
2157 /* Don't try report anything if there are no threads --
2158 the program is dead. */
2159 && thread_count () != 0
2160 /* If the command already reports the thread change, no need to do it
2162 && !command_notifies_uscc_observer (command
.get ()))
2164 struct mi_interp
*mi
= (struct mi_interp
*) top_level_interpreter ();
2165 int report_change
= 0;
2167 if (command
->thread
== -1)
2169 report_change
= (!ptid_equal (previous_ptid
, null_ptid
)
2170 && !ptid_equal (inferior_ptid
, previous_ptid
)
2171 && !ptid_equal (inferior_ptid
, null_ptid
));
2173 else if (!ptid_equal (inferior_ptid
, null_ptid
))
2175 struct thread_info
*ti
= inferior_thread ();
2177 report_change
= (ti
->global_num
!= command
->thread
);
2182 observer_notify_user_selected_context_changed
2183 (USER_SELECTED_THREAD
| USER_SELECTED_FRAME
);
2190 mi_cmd_execute (struct mi_parse
*parse
)
2192 struct cleanup
*cleanup
;
2194 cleanup
= prepare_execute_command ();
2196 if (parse
->all
&& parse
->thread_group
!= -1)
2197 error (_("Cannot specify --thread-group together with --all"));
2199 if (parse
->all
&& parse
->thread
!= -1)
2200 error (_("Cannot specify --thread together with --all"));
2202 if (parse
->thread_group
!= -1 && parse
->thread
!= -1)
2203 error (_("Cannot specify --thread together with --thread-group"));
2205 if (parse
->frame
!= -1 && parse
->thread
== -1)
2206 error (_("Cannot specify --frame without --thread"));
2208 if (parse
->thread_group
!= -1)
2210 struct inferior
*inf
= find_inferior_id (parse
->thread_group
);
2211 struct thread_info
*tp
= 0;
2214 error (_("Invalid thread group for the --thread-group option"));
2216 set_current_inferior (inf
);
2217 /* This behaviour means that if --thread-group option identifies
2218 an inferior with multiple threads, then a random one will be
2219 picked. This is not a problem -- frontend should always
2220 provide --thread if it wishes to operate on a specific
2223 tp
= any_live_thread_of_process (inf
->pid
);
2224 switch_to_thread (tp
? tp
->ptid
: null_ptid
);
2225 set_current_program_space (inf
->pspace
);
2228 if (parse
->thread
!= -1)
2230 struct thread_info
*tp
= find_thread_global_id (parse
->thread
);
2233 error (_("Invalid thread id: %d"), parse
->thread
);
2235 if (is_exited (tp
->ptid
))
2236 error (_("Thread id: %d has terminated"), parse
->thread
);
2238 switch_to_thread (tp
->ptid
);
2241 if (parse
->frame
!= -1)
2243 struct frame_info
*fid
;
2244 int frame
= parse
->frame
;
2246 fid
= find_relative_frame (get_current_frame (), &frame
);
2248 /* find_relative_frame was successful */
2251 error (_("Invalid frame id: %d"), frame
);
2254 if (parse
->language
!= language_unknown
)
2256 make_cleanup_restore_current_language ();
2257 set_language (parse
->language
);
2260 current_context
= parse
;
2262 if (parse
->cmd
->argv_func
!= NULL
)
2264 parse
->cmd
->argv_func (parse
->command
, parse
->argv
, parse
->argc
);
2266 else if (parse
->cmd
->cli
.cmd
!= 0)
2268 /* FIXME: DELETE THIS. */
2269 /* The operation is still implemented by a cli command. */
2270 /* Must be a synchronous one. */
2271 mi_execute_cli_command (parse
->cmd
->cli
.cmd
, parse
->cmd
->cli
.args_p
,
2276 /* FIXME: DELETE THIS. */
2279 stb
.puts ("Undefined mi command: ");
2280 stb
.putstr (parse
->command
, '"');
2281 stb
.puts (" (missing implementation)");
2285 do_cleanups (cleanup
);
2288 /* FIXME: This is just a hack so we can get some extra commands going.
2289 We don't want to channel things through the CLI, but call libgdb directly.
2290 Use only for synchronous commands. */
2293 mi_execute_cli_command (const char *cmd
, int args_p
, const char *args
)
2297 struct cleanup
*old_cleanups
;
2301 run
= xstrprintf ("%s %s", cmd
, args
);
2303 run
= xstrdup (cmd
);
2305 /* FIXME: gdb_???? */
2306 fprintf_unfiltered (gdb_stdout
, "cli=%s run=%s\n",
2308 old_cleanups
= make_cleanup (xfree
, run
);
2309 execute_command (run
, 0 /* from_tty */ );
2310 do_cleanups (old_cleanups
);
2316 mi_execute_async_cli_command (const char *cli_command
, char **argv
, int argc
)
2318 struct cleanup
*old_cleanups
;
2322 run
= xstrprintf ("%s %s&", cli_command
, argc
? *argv
: "");
2324 run
= xstrprintf ("%s %s", cli_command
, argc
? *argv
: "");
2325 old_cleanups
= make_cleanup (xfree
, run
);
2327 execute_command (run
, 0 /* from_tty */ );
2329 /* Do this before doing any printing. It would appear that some
2330 print code leaves garbage around in the buffer. */
2331 do_cleanups (old_cleanups
);
2335 mi_load_progress (const char *section_name
,
2336 unsigned long sent_so_far
,
2337 unsigned long total_section
,
2338 unsigned long total_sent
,
2339 unsigned long grand_total
)
2341 using namespace std::chrono
;
2342 static steady_clock::time_point last_update
;
2343 static char *previous_sect_name
= NULL
;
2345 struct ui_out
*saved_uiout
;
2346 struct ui_out
*uiout
;
2347 struct mi_interp
*mi
= (struct mi_interp
*) current_interpreter ();
2349 /* This function is called through deprecated_show_load_progress
2350 which means uiout may not be correct. Fix it for the duration
2351 of this function. */
2352 saved_uiout
= current_uiout
;
2354 if (current_interp_named_p (INTERP_MI
)
2355 || current_interp_named_p (INTERP_MI2
))
2356 current_uiout
= mi_out_new (2);
2357 else if (current_interp_named_p (INTERP_MI1
))
2358 current_uiout
= mi_out_new (1);
2359 else if (current_interp_named_p (INTERP_MI3
))
2360 current_uiout
= mi_out_new (3);
2364 uiout
= current_uiout
;
2366 new_section
= (previous_sect_name
?
2367 strcmp (previous_sect_name
, section_name
) : 1);
2370 xfree (previous_sect_name
);
2371 previous_sect_name
= xstrdup (section_name
);
2374 fputs_unfiltered (current_token
, mi
->raw_stdout
);
2375 fputs_unfiltered ("+download", mi
->raw_stdout
);
2377 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
2378 uiout
->field_string ("section", section_name
);
2379 uiout
->field_int ("section-size", total_section
);
2380 uiout
->field_int ("total-size", grand_total
);
2382 mi_out_put (uiout
, mi
->raw_stdout
);
2383 fputs_unfiltered ("\n", mi
->raw_stdout
);
2384 gdb_flush (mi
->raw_stdout
);
2387 steady_clock::time_point time_now
= steady_clock::now ();
2388 if (time_now
- last_update
> milliseconds (500))
2390 last_update
= time_now
;
2392 fputs_unfiltered (current_token
, mi
->raw_stdout
);
2393 fputs_unfiltered ("+download", mi
->raw_stdout
);
2395 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
2396 uiout
->field_string ("section", section_name
);
2397 uiout
->field_int ("section-sent", sent_so_far
);
2398 uiout
->field_int ("section-size", total_section
);
2399 uiout
->field_int ("total-sent", total_sent
);
2400 uiout
->field_int ("total-size", grand_total
);
2402 mi_out_put (uiout
, mi
->raw_stdout
);
2403 fputs_unfiltered ("\n", mi
->raw_stdout
);
2404 gdb_flush (mi
->raw_stdout
);
2408 current_uiout
= saved_uiout
;
2412 timestamp (struct mi_timestamp
*tv
)
2414 using namespace std::chrono
;
2416 tv
->wallclock
= steady_clock::now ();
2417 run_time_clock::now (tv
->utime
, tv
->stime
);
2421 print_diff_now (struct ui_file
*file
, struct mi_timestamp
*start
)
2423 struct mi_timestamp now
;
2426 print_diff (file
, start
, &now
);
2430 mi_print_timing_maybe (struct ui_file
*file
)
2432 /* If the command is -enable-timing then do_timings may be true
2433 whilst current_command_ts is not initialized. */
2434 if (do_timings
&& current_command_ts
)
2435 print_diff_now (file
, current_command_ts
);
2439 print_diff (struct ui_file
*file
, struct mi_timestamp
*start
,
2440 struct mi_timestamp
*end
)
2442 using namespace std::chrono
;
2444 duration
<double> wallclock
= end
->wallclock
- start
->wallclock
;
2445 duration
<double> utime
= end
->utime
- start
->utime
;
2446 duration
<double> stime
= end
->stime
- start
->stime
;
2450 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
2451 wallclock
.count (), utime
.count (), stime
.count ());
2455 mi_cmd_trace_define_variable (const char *command
, char **argv
, int argc
)
2457 LONGEST initval
= 0;
2458 struct trace_state_variable
*tsv
;
2461 if (argc
!= 1 && argc
!= 2)
2462 error (_("Usage: -trace-define-variable VARIABLE [VALUE]"));
2466 error (_("Name of trace variable should start with '$'"));
2468 validate_trace_state_variable_name (name
);
2470 tsv
= find_trace_state_variable (name
);
2472 tsv
= create_trace_state_variable (name
);
2475 initval
= value_as_long (parse_and_eval (argv
[1]));
2477 tsv
->initial_value
= initval
;
2481 mi_cmd_trace_list_variables (const char *command
, char **argv
, int argc
)
2484 error (_("-trace-list-variables: no arguments allowed"));
2486 tvariables_info_1 ();
2490 mi_cmd_trace_find (const char *command
, char **argv
, int argc
)
2495 error (_("trace selection mode is required"));
2499 if (strcmp (mode
, "none") == 0)
2501 tfind_1 (tfind_number
, -1, 0, 0, 0);
2505 check_trace_running (current_trace_status ());
2507 if (strcmp (mode
, "frame-number") == 0)
2510 error (_("frame number is required"));
2511 tfind_1 (tfind_number
, atoi (argv
[1]), 0, 0, 0);
2513 else if (strcmp (mode
, "tracepoint-number") == 0)
2516 error (_("tracepoint number is required"));
2517 tfind_1 (tfind_tp
, atoi (argv
[1]), 0, 0, 0);
2519 else if (strcmp (mode
, "pc") == 0)
2522 error (_("PC is required"));
2523 tfind_1 (tfind_pc
, 0, parse_and_eval_address (argv
[1]), 0, 0);
2525 else if (strcmp (mode
, "pc-inside-range") == 0)
2528 error (_("Start and end PC are required"));
2529 tfind_1 (tfind_range
, 0, parse_and_eval_address (argv
[1]),
2530 parse_and_eval_address (argv
[2]), 0);
2532 else if (strcmp (mode
, "pc-outside-range") == 0)
2535 error (_("Start and end PC are required"));
2536 tfind_1 (tfind_outside
, 0, parse_and_eval_address (argv
[1]),
2537 parse_and_eval_address (argv
[2]), 0);
2539 else if (strcmp (mode
, "line") == 0)
2541 struct symtabs_and_lines sals
;
2542 struct symtab_and_line sal
;
2543 static CORE_ADDR start_pc
, end_pc
;
2544 struct cleanup
*back_to
;
2547 error (_("Line is required"));
2549 sals
= decode_line_with_current_source (argv
[1],
2550 DECODE_LINE_FUNFIRSTLINE
);
2551 back_to
= make_cleanup (xfree
, sals
.sals
);
2555 if (sal
.symtab
== 0)
2556 error (_("Could not find the specified line"));
2558 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2559 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, 0);
2561 error (_("Could not find the specified line"));
2563 do_cleanups (back_to
);
2566 error (_("Invalid mode '%s'"), mode
);
2568 if (has_stack_frames () || get_traceframe_number () >= 0)
2569 print_stack_frame (get_selected_frame (NULL
), 1, LOC_AND_ADDRESS
, 1);
2573 mi_cmd_trace_save (const char *command
, char **argv
, int argc
)
2575 int target_saves
= 0;
2576 int generate_ctf
= 0;
2583 TARGET_SAVE_OPT
, CTF_OPT
2585 static const struct mi_opt opts
[] =
2587 {"r", TARGET_SAVE_OPT
, 0},
2588 {"ctf", CTF_OPT
, 0},
2594 int opt
= mi_getopt ("-trace-save", argc
, argv
, opts
,
2599 switch ((enum opt
) opt
)
2601 case TARGET_SAVE_OPT
:
2610 if (argc
- oind
!= 1)
2611 error (_("Exactly one argument required "
2612 "(file in which to save trace data)"));
2614 filename
= argv
[oind
];
2617 trace_save_ctf (filename
, target_saves
);
2619 trace_save_tfile (filename
, target_saves
);
2623 mi_cmd_trace_start (const char *command
, char **argv
, int argc
)
2625 start_tracing (NULL
);
2629 mi_cmd_trace_status (const char *command
, char **argv
, int argc
)
2631 trace_status_mi (0);
2635 mi_cmd_trace_stop (const char *command
, char **argv
, int argc
)
2637 stop_tracing (NULL
);
2638 trace_status_mi (1);
2641 /* Implement the "-ada-task-info" command. */
2644 mi_cmd_ada_task_info (const char *command
, char **argv
, int argc
)
2646 if (argc
!= 0 && argc
!= 1)
2647 error (_("Invalid MI command"));
2649 print_ada_task_info (current_uiout
, argv
[0], current_inferior ());
2652 /* Print EXPRESSION according to VALUES. */
2655 print_variable_or_computed (const char *expression
, enum print_values values
)
2659 struct ui_out
*uiout
= current_uiout
;
2663 expression_up expr
= parse_expression (expression
);
2665 if (values
== PRINT_SIMPLE_VALUES
)
2666 val
= evaluate_type (expr
.get ());
2668 val
= evaluate_expression (expr
.get ());
2670 gdb::optional
<ui_out_emit_tuple
> tuple_emitter
;
2671 if (values
!= PRINT_NO_VALUES
)
2672 tuple_emitter
.emplace (uiout
, nullptr);
2673 uiout
->field_string ("name", expression
);
2677 case PRINT_SIMPLE_VALUES
:
2678 type
= check_typedef (value_type (val
));
2679 type_print (value_type (val
), "", &stb
, -1);
2680 uiout
->field_stream ("type", stb
);
2681 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
2682 && TYPE_CODE (type
) != TYPE_CODE_STRUCT
2683 && TYPE_CODE (type
) != TYPE_CODE_UNION
)
2685 struct value_print_options opts
;
2687 get_no_prettyformat_print_options (&opts
);
2689 common_val_print (val
, &stb
, 0, &opts
, current_language
);
2690 uiout
->field_stream ("value", stb
);
2693 case PRINT_ALL_VALUES
:
2695 struct value_print_options opts
;
2697 get_no_prettyformat_print_options (&opts
);
2699 common_val_print (val
, &stb
, 0, &opts
, current_language
);
2700 uiout
->field_stream ("value", stb
);
2706 /* Implement the "-trace-frame-collected" command. */
2709 mi_cmd_trace_frame_collected (const char *command
, char **argv
, int argc
)
2711 struct bp_location
*tloc
;
2713 struct collection_list
*clist
;
2714 struct collection_list tracepoint_list
, stepping_list
;
2715 struct traceframe_info
*tinfo
;
2717 enum print_values var_print_values
= PRINT_ALL_VALUES
;
2718 enum print_values comp_print_values
= PRINT_ALL_VALUES
;
2719 int registers_format
= 'x';
2720 int memory_contents
= 0;
2721 struct ui_out
*uiout
= current_uiout
;
2729 static const struct mi_opt opts
[] =
2731 {"-var-print-values", VAR_PRINT_VALUES
, 1},
2732 {"-comp-print-values", COMP_PRINT_VALUES
, 1},
2733 {"-registers-format", REGISTERS_FORMAT
, 1},
2734 {"-memory-contents", MEMORY_CONTENTS
, 0},
2741 int opt
= mi_getopt ("-trace-frame-collected", argc
, argv
, opts
,
2745 switch ((enum opt
) opt
)
2747 case VAR_PRINT_VALUES
:
2748 var_print_values
= mi_parse_print_values (oarg
);
2750 case COMP_PRINT_VALUES
:
2751 comp_print_values
= mi_parse_print_values (oarg
);
2753 case REGISTERS_FORMAT
:
2754 registers_format
= oarg
[0];
2755 case MEMORY_CONTENTS
:
2756 memory_contents
= 1;
2762 error (_("Usage: -trace-frame-collected "
2763 "[--var-print-values PRINT_VALUES] "
2764 "[--comp-print-values PRINT_VALUES] "
2765 "[--registers-format FORMAT]"
2766 "[--memory-contents]"));
2768 /* This throws an error is not inspecting a trace frame. */
2769 tloc
= get_traceframe_location (&stepping_frame
);
2771 /* This command only makes sense for the current frame, not the
2773 scoped_restore_current_thread restore_thread
;
2774 select_frame (get_current_frame ());
2776 encode_actions (tloc
, &tracepoint_list
, &stepping_list
);
2779 clist
= &stepping_list
;
2781 clist
= &tracepoint_list
;
2783 tinfo
= get_traceframe_info ();
2785 /* Explicitly wholly collected variables. */
2789 ui_out_emit_list
list_emitter (uiout
, "explicit-variables");
2790 const std::vector
<std::string
> &wholly_collected
2791 = clist
->wholly_collected ();
2792 for (size_t i
= 0; i
< wholly_collected
.size (); i
++)
2794 const std::string
&str
= wholly_collected
[i
];
2795 print_variable_or_computed (str
.c_str (), var_print_values
);
2799 /* Computed expressions. */
2804 ui_out_emit_list
list_emitter (uiout
, "computed-expressions");
2806 const std::vector
<std::string
> &computed
= clist
->computed ();
2807 for (size_t i
= 0; i
< computed
.size (); i
++)
2809 const std::string
&str
= computed
[i
];
2810 print_variable_or_computed (str
.c_str (), comp_print_values
);
2814 /* Registers. Given pseudo-registers, and that some architectures
2815 (like MIPS) actually hide the raw registers, we don't go through
2816 the trace frame info, but instead consult the register cache for
2817 register availability. */
2819 struct frame_info
*frame
;
2820 struct gdbarch
*gdbarch
;
2824 ui_out_emit_list
list_emitter (uiout
, "registers");
2826 frame
= get_selected_frame (NULL
);
2827 gdbarch
= get_frame_arch (frame
);
2828 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
2830 for (regnum
= 0; regnum
< numregs
; regnum
++)
2832 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
2833 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
2836 output_register (frame
, regnum
, registers_format
, 1);
2840 /* Trace state variables. */
2842 struct cleanup
*list_cleanup
;
2847 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "tvars");
2850 make_cleanup (free_current_contents
, &tsvname
);
2852 for (i
= 0; VEC_iterate (int, tinfo
->tvars
, i
, tvar
); i
++)
2854 struct trace_state_variable
*tsv
;
2856 tsv
= find_trace_state_variable_by_number (tvar
);
2858 ui_out_emit_tuple
tuple_emitter (uiout
, NULL
);
2862 tsvname
= (char *) xrealloc (tsvname
, strlen (tsv
->name
) + 2);
2864 strcpy (tsvname
+ 1, tsv
->name
);
2865 uiout
->field_string ("name", tsvname
);
2867 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
2869 uiout
->field_int ("current", tsv
->value
);
2873 uiout
->field_skip ("name");
2874 uiout
->field_skip ("current");
2878 do_cleanups (list_cleanup
);
2883 struct cleanup
*list_cleanup
;
2884 VEC(mem_range_s
) *available_memory
= NULL
;
2885 struct mem_range
*r
;
2888 traceframe_available_memory (&available_memory
, 0, ULONGEST_MAX
);
2889 make_cleanup (VEC_cleanup(mem_range_s
), &available_memory
);
2891 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "memory");
2893 for (i
= 0; VEC_iterate (mem_range_s
, available_memory
, i
, r
); i
++)
2895 struct cleanup
*cleanup_child
;
2897 struct gdbarch
*gdbarch
= target_gdbarch ();
2899 cleanup_child
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2901 uiout
->field_core_addr ("address", gdbarch
, r
->start
);
2902 uiout
->field_int ("length", r
->length
);
2904 data
= (gdb_byte
*) xmalloc (r
->length
);
2905 make_cleanup (xfree
, data
);
2907 if (memory_contents
)
2909 if (target_read_memory (r
->start
, data
, r
->length
) == 0)
2914 data_str
= (char *) xmalloc (r
->length
* 2 + 1);
2915 make_cleanup (xfree
, data_str
);
2917 for (m
= 0, p
= data_str
; m
< r
->length
; ++m
, p
+= 2)
2918 sprintf (p
, "%02x", data
[m
]);
2919 uiout
->field_string ("contents", data_str
);
2922 uiout
->field_skip ("contents");
2924 do_cleanups (cleanup_child
);
2927 do_cleanups (list_cleanup
);
2932 _initialize_mi_main (void)
2934 struct cmd_list_element
*c
;
2936 add_setshow_boolean_cmd ("mi-async", class_run
,
2938 Set whether MI asynchronous mode is enabled."), _("\
2939 Show whether MI asynchronous mode is enabled."), _("\
2940 Tells GDB whether MI should be in asynchronous mode."),
2941 set_mi_async_command
,
2942 show_mi_async_command
,
2946 /* Alias old "target-async" to "mi-async". */
2947 c
= add_alias_cmd ("target-async", "mi-async", class_run
, 0, &setlist
);
2948 deprecate_cmd (c
, "set mi-async");
2949 c
= add_alias_cmd ("target-async", "mi-async", class_run
, 0, &showlist
);
2950 deprecate_cmd (c
, "show mi-async");