3 Copyright (C) 2000-2016 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"
59 #include "run-time-clock.h"
69 /* This is used to pass the current command timestamp down to
70 continuation routines. */
71 static struct mi_timestamp
*current_command_ts
;
73 static int do_timings
= 0;
76 /* Few commands would like to know if options like --thread-group were
77 explicitly specified. This variable keeps the current parsed
78 command including all option, and make it possible. */
79 static struct mi_parse
*current_context
;
81 int running_result_record_printed
= 1;
83 /* Flag indicating that the target has proceeded since the last
84 command was issued. */
87 extern void _initialize_mi_main (void);
88 static void mi_cmd_execute (struct mi_parse
*parse
);
90 static void mi_execute_cli_command (const char *cmd
, int args_p
,
92 static void mi_execute_async_cli_command (char *cli_command
,
93 char **argv
, int argc
);
94 static int register_changed_p (int regnum
, struct regcache
*,
96 static void output_register (struct frame_info
*, int regnum
, int format
,
97 int skip_unavailable
);
99 /* Controls whether the frontend wants MI in async mode. */
100 static int mi_async
= 0;
102 /* The set command writes to this variable. If the inferior is
103 executing, mi_async is *not* updated. */
104 static int mi_async_1
= 0;
107 set_mi_async_command (char *args
, int from_tty
,
108 struct cmd_list_element
*c
)
110 if (have_live_inferiors ())
112 mi_async_1
= mi_async
;
113 error (_("Cannot change this setting while the inferior is running."));
116 mi_async
= mi_async_1
;
120 show_mi_async_command (struct ui_file
*file
, int from_tty
,
121 struct cmd_list_element
*c
,
124 fprintf_filtered (file
,
125 _("Whether MI is in asynchronous mode is %s.\n"),
129 /* A wrapper for target_can_async_p that takes the MI setting into
135 return mi_async
&& target_can_async_p ();
138 /* Command implementations. FIXME: Is this libgdb? No. This is the MI
139 layer that calls libgdb. Any operation used in the below should be
142 static void timestamp (struct mi_timestamp
*tv
);
144 static void print_diff (struct ui_file
*file
, struct mi_timestamp
*start
,
145 struct mi_timestamp
*end
);
148 mi_cmd_gdb_exit (char *command
, char **argv
, int argc
)
151 = (struct mi_interp
*) interp_data (current_interpreter ());
153 /* We have to print everything right here because we never return. */
155 fputs_unfiltered (current_token
, mi
->raw_stdout
);
156 fputs_unfiltered ("^exit\n", mi
->raw_stdout
);
157 mi_out_put (current_uiout
, mi
->raw_stdout
);
158 gdb_flush (mi
->raw_stdout
);
159 /* FIXME: The function called is not yet a formal libgdb function. */
160 quit_force (NULL
, FROM_TTY
);
164 mi_cmd_exec_next (char *command
, char **argv
, int argc
)
166 /* FIXME: Should call a libgdb function, not a cli wrapper. */
167 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
168 mi_execute_async_cli_command ("reverse-next", argv
+ 1, argc
- 1);
170 mi_execute_async_cli_command ("next", argv
, argc
);
174 mi_cmd_exec_next_instruction (char *command
, char **argv
, int argc
)
176 /* FIXME: Should call a libgdb function, not a cli wrapper. */
177 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
178 mi_execute_async_cli_command ("reverse-nexti", argv
+ 1, argc
- 1);
180 mi_execute_async_cli_command ("nexti", argv
, argc
);
184 mi_cmd_exec_step (char *command
, char **argv
, int argc
)
186 /* FIXME: Should call a libgdb function, not a cli wrapper. */
187 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
188 mi_execute_async_cli_command ("reverse-step", argv
+ 1, argc
- 1);
190 mi_execute_async_cli_command ("step", argv
, argc
);
194 mi_cmd_exec_step_instruction (char *command
, char **argv
, int argc
)
196 /* FIXME: Should call a libgdb function, not a cli wrapper. */
197 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
198 mi_execute_async_cli_command ("reverse-stepi", argv
+ 1, argc
- 1);
200 mi_execute_async_cli_command ("stepi", argv
, argc
);
204 mi_cmd_exec_finish (char *command
, char **argv
, int argc
)
206 /* FIXME: Should call a libgdb function, not a cli wrapper. */
207 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
208 mi_execute_async_cli_command ("reverse-finish", argv
+ 1, argc
- 1);
210 mi_execute_async_cli_command ("finish", argv
, argc
);
214 mi_cmd_exec_return (char *command
, char **argv
, int argc
)
216 /* This command doesn't really execute the target, it just pops the
217 specified number of frames. */
219 /* Call return_command with from_tty argument equal to 0 so as to
220 avoid being queried. */
221 return_command (*argv
, 0);
223 /* Call return_command with from_tty argument equal to 0 so as to
224 avoid being queried. */
225 return_command (NULL
, 0);
227 /* Because we have called return_command with from_tty = 0, we need
228 to print the frame here. */
229 print_stack_frame (get_selected_frame (NULL
), 1, LOC_AND_ADDRESS
, 1);
233 mi_cmd_exec_jump (char *args
, char **argv
, int argc
)
235 /* FIXME: Should call a libgdb function, not a cli wrapper. */
236 mi_execute_async_cli_command ("jump", argv
, argc
);
240 proceed_thread (struct thread_info
*thread
, int pid
)
242 if (!is_stopped (thread
->ptid
))
245 if (pid
!= 0 && ptid_get_pid (thread
->ptid
) != pid
)
248 switch_to_thread (thread
->ptid
);
249 clear_proceed_status (0);
250 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
);
254 proceed_thread_callback (struct thread_info
*thread
, void *arg
)
256 int pid
= *(int *)arg
;
258 proceed_thread (thread
, pid
);
263 exec_continue (char **argv
, int argc
)
265 prepare_execution_command (¤t_target
, mi_async_p ());
269 /* In non-stop mode, 'resume' always resumes a single thread.
270 Therefore, to resume all threads of the current inferior, or
271 all threads in all inferiors, we need to iterate over
274 See comment on infcmd.c:proceed_thread_callback for rationale. */
275 if (current_context
->all
|| current_context
->thread_group
!= -1)
278 struct cleanup
*back_to
= make_cleanup_restore_current_thread ();
280 if (!current_context
->all
)
283 = find_inferior_id (current_context
->thread_group
);
287 iterate_over_threads (proceed_thread_callback
, &pid
);
288 do_cleanups (back_to
);
297 scoped_restore save_multi
= make_scoped_restore (&sched_multi
);
299 if (current_context
->all
)
306 /* In all-stop mode, -exec-continue traditionally resumed
307 either all threads, or one thread, depending on the
308 'scheduler-locking' variable. Let's continue to do the
316 exec_direction_forward (void *notused
)
318 execution_direction
= EXEC_FORWARD
;
322 exec_reverse_continue (char **argv
, int argc
)
324 enum exec_direction_kind dir
= execution_direction
;
325 struct cleanup
*old_chain
;
327 if (dir
== EXEC_REVERSE
)
328 error (_("Already in reverse mode."));
330 if (!target_can_execute_reverse
)
331 error (_("Target %s does not support this command."), target_shortname
);
333 old_chain
= make_cleanup (exec_direction_forward
, NULL
);
334 execution_direction
= EXEC_REVERSE
;
335 exec_continue (argv
, argc
);
336 do_cleanups (old_chain
);
340 mi_cmd_exec_continue (char *command
, char **argv
, int argc
)
342 if (argc
> 0 && strcmp (argv
[0], "--reverse") == 0)
343 exec_reverse_continue (argv
+ 1, argc
- 1);
345 exec_continue (argv
, argc
);
349 interrupt_thread_callback (struct thread_info
*thread
, void *arg
)
351 int pid
= *(int *)arg
;
353 if (!is_running (thread
->ptid
))
356 if (ptid_get_pid (thread
->ptid
) != pid
)
359 target_stop (thread
->ptid
);
363 /* Interrupt the execution of the target. Note how we must play
364 around with the token variables, in order to display the current
365 token in the result of the interrupt command, and the previous
366 execution token when the target finally stops. See comments in
370 mi_cmd_exec_interrupt (char *command
, char **argv
, int argc
)
372 /* In all-stop mode, everything stops, so we don't need to try
373 anything specific. */
376 interrupt_target_1 (0);
380 if (current_context
->all
)
382 /* This will interrupt all threads in all inferiors. */
383 interrupt_target_1 (1);
385 else if (current_context
->thread_group
!= -1)
387 struct inferior
*inf
= find_inferior_id (current_context
->thread_group
);
389 iterate_over_threads (interrupt_thread_callback
, &inf
->pid
);
393 /* Interrupt just the current thread -- either explicitly
394 specified via --thread or whatever was current before
395 MI command was sent. */
396 interrupt_target_1 (0);
400 /* Callback for iterate_over_inferiors which starts the execution
401 of the given inferior.
403 ARG is a pointer to an integer whose value, if non-zero, indicates
404 that the program should be stopped when reaching the main subprogram
405 (similar to what the CLI "start" command does). */
408 run_one_inferior (struct inferior
*inf
, void *arg
)
410 int start_p
= *(int *) arg
;
411 const char *run_cmd
= start_p
? "start" : "run";
412 struct target_ops
*run_target
= find_run_target ();
413 int async_p
= mi_async
&& run_target
->to_can_async_p (run_target
);
417 if (inf
->pid
!= ptid_get_pid (inferior_ptid
))
419 struct thread_info
*tp
;
421 tp
= any_thread_of_process (inf
->pid
);
423 error (_("Inferior has no threads."));
425 switch_to_thread (tp
->ptid
);
430 set_current_inferior (inf
);
431 switch_to_thread (null_ptid
);
432 set_current_program_space (inf
->pspace
);
434 mi_execute_cli_command (run_cmd
, async_p
,
435 async_p
? "&" : NULL
);
440 mi_cmd_exec_run (char *command
, char **argv
, int argc
)
444 /* Parse the command options. */
449 static const struct mi_opt opts
[] =
451 {"-start", START_OPT
, 0},
460 int opt
= mi_getopt ("-exec-run", argc
, argv
, opts
, &oind
, &oarg
);
464 switch ((enum opt
) opt
)
472 /* This command does not accept any argument. Make sure the user
473 did not provide any. */
475 error (_("Invalid argument: %s"), argv
[oind
]);
477 if (current_context
->all
)
479 struct cleanup
*back_to
= save_current_space_and_thread ();
481 iterate_over_inferiors (run_one_inferior
, &start_p
);
482 do_cleanups (back_to
);
486 const char *run_cmd
= start_p
? "start" : "run";
487 struct target_ops
*run_target
= find_run_target ();
488 int async_p
= mi_async
&& run_target
->to_can_async_p (run_target
);
490 mi_execute_cli_command (run_cmd
, async_p
,
491 async_p
? "&" : NULL
);
497 find_thread_of_process (struct thread_info
*ti
, void *p
)
501 if (ptid_get_pid (ti
->ptid
) == pid
&& !is_exited (ti
->ptid
))
508 mi_cmd_target_detach (char *command
, char **argv
, int argc
)
510 if (argc
!= 0 && argc
!= 1)
511 error (_("Usage: -target-detach [pid | thread-group]"));
515 struct thread_info
*tp
;
519 /* First see if we are dealing with a thread-group id. */
522 struct inferior
*inf
;
523 int id
= strtoul (argv
[0] + 1, &end
, 0);
526 error (_("Invalid syntax of thread-group id '%s'"), argv
[0]);
528 inf
= find_inferior_id (id
);
530 error (_("Non-existent thread-group id '%d'"), id
);
536 /* We must be dealing with a pid. */
537 pid
= strtol (argv
[0], &end
, 10);
540 error (_("Invalid identifier '%s'"), argv
[0]);
543 /* Pick any thread in the desired process. Current
544 target_detach detaches from the parent of inferior_ptid. */
545 tp
= iterate_over_threads (find_thread_of_process
, &pid
);
547 error (_("Thread group is empty"));
549 switch_to_thread (tp
->ptid
);
552 detach_command (NULL
, 0);
556 mi_cmd_thread_select (char *command
, char **argv
, int argc
)
559 char *mi_error_message
;
560 ptid_t previous_ptid
= inferior_ptid
;
563 error (_("-thread-select: USAGE: threadnum."));
565 rc
= gdb_thread_select (current_uiout
, argv
[0], &mi_error_message
);
567 /* If thread switch did not succeed don't notify or print. */
568 if (rc
== GDB_RC_FAIL
)
570 make_cleanup (xfree
, mi_error_message
);
571 error ("%s", mi_error_message
);
574 print_selected_thread_frame (current_uiout
,
575 USER_SELECTED_THREAD
| USER_SELECTED_FRAME
);
577 /* Notify if the thread has effectively changed. */
578 if (!ptid_equal (inferior_ptid
, previous_ptid
))
580 observer_notify_user_selected_context_changed (USER_SELECTED_THREAD
581 | USER_SELECTED_FRAME
);
586 mi_cmd_thread_list_ids (char *command
, char **argv
, int argc
)
589 char *mi_error_message
;
592 error (_("-thread-list-ids: No arguments required."));
594 rc
= gdb_list_thread_ids (current_uiout
, &mi_error_message
);
596 if (rc
== GDB_RC_FAIL
)
598 make_cleanup (xfree
, mi_error_message
);
599 error ("%s", mi_error_message
);
604 mi_cmd_thread_info (char *command
, char **argv
, int argc
)
606 if (argc
!= 0 && argc
!= 1)
607 error (_("Invalid MI command"));
609 print_thread_info (current_uiout
, argv
[0], -1);
612 struct collect_cores_data
620 collect_cores (struct thread_info
*ti
, void *xdata
)
622 struct collect_cores_data
*data
= (struct collect_cores_data
*) xdata
;
624 if (ptid_get_pid (ti
->ptid
) == data
->pid
)
626 int core
= target_core_of_thread (ti
->ptid
);
629 VEC_safe_push (int, data
->cores
, core
);
636 unique (int *b
, int *e
)
646 struct print_one_inferior_data
649 VEC (int) *inferiors
;
653 print_one_inferior (struct inferior
*inferior
, void *xdata
)
655 struct print_one_inferior_data
*top_data
656 = (struct print_one_inferior_data
*) xdata
;
657 struct ui_out
*uiout
= current_uiout
;
659 if (VEC_empty (int, top_data
->inferiors
)
660 || bsearch (&(inferior
->pid
), VEC_address (int, top_data
->inferiors
),
661 VEC_length (int, top_data
->inferiors
), sizeof (int),
662 compare_positive_ints
))
664 struct collect_cores_data data
;
665 struct cleanup
*back_to
666 = make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
668 uiout
->field_fmt ("id", "i%d", inferior
->num
);
669 uiout
->field_string ("type", "process");
670 if (inferior
->has_exit_code
)
671 uiout
->field_string ("exit-code",
672 int_string (inferior
->exit_code
, 8, 0, 0, 1));
673 if (inferior
->pid
!= 0)
674 uiout
->field_int ("pid", inferior
->pid
);
676 if (inferior
->pspace
->pspace_exec_filename
!= NULL
)
678 uiout
->field_string ("executable",
679 inferior
->pspace
->pspace_exec_filename
);
683 if (inferior
->pid
!= 0)
685 data
.pid
= inferior
->pid
;
686 iterate_over_threads (collect_cores
, &data
);
689 if (!VEC_empty (int, data
.cores
))
692 struct cleanup
*back_to_2
=
693 make_cleanup_ui_out_list_begin_end (uiout
, "cores");
695 qsort (VEC_address (int, data
.cores
),
696 VEC_length (int, data
.cores
), sizeof (int),
697 compare_positive_ints
);
699 b
= VEC_address (int, data
.cores
);
700 e
= b
+ VEC_length (int, data
.cores
);
704 uiout
->field_int (NULL
, *b
);
706 do_cleanups (back_to_2
);
709 if (top_data
->recurse
)
710 print_thread_info (uiout
, NULL
, inferior
->pid
);
712 do_cleanups (back_to
);
718 /* Output a field named 'cores' with a list as the value. The
719 elements of the list are obtained by splitting 'cores' on
723 output_cores (struct ui_out
*uiout
, const char *field_name
, const char *xcores
)
725 struct cleanup
*back_to
= make_cleanup_ui_out_list_begin_end (uiout
,
727 char *cores
= xstrdup (xcores
);
730 make_cleanup (xfree
, cores
);
732 for (p
= strtok (p
, ","); p
; p
= strtok (NULL
, ","))
733 uiout
->field_string (NULL
, p
);
735 do_cleanups (back_to
);
739 free_vector_of_ints (void *xvector
)
741 VEC (int) **vector
= (VEC (int) **) xvector
;
743 VEC_free (int, *vector
);
747 do_nothing (splay_tree_key k
)
752 free_vector_of_osdata_items (splay_tree_value xvalue
)
754 VEC (osdata_item_s
) *value
= (VEC (osdata_item_s
) *) xvalue
;
756 /* We don't free the items itself, it will be done separately. */
757 VEC_free (osdata_item_s
, value
);
761 splay_tree_int_comparator (splay_tree_key xa
, splay_tree_key xb
)
770 free_splay_tree (void *xt
)
772 splay_tree t
= (splay_tree
) xt
;
773 splay_tree_delete (t
);
777 list_available_thread_groups (VEC (int) *ids
, int recurse
)
780 struct osdata_item
*item
;
782 struct ui_out
*uiout
= current_uiout
;
783 struct cleanup
*cleanup
;
785 /* This keeps a map from integer (pid) to VEC (struct osdata_item *)*
786 The vector contains information about all threads for the given pid.
787 This is assigned an initial value to avoid "may be used uninitialized"
789 splay_tree tree
= NULL
;
791 /* get_osdata will throw if it cannot return data. */
792 data
= get_osdata ("processes");
793 cleanup
= make_cleanup_osdata_free (data
);
797 struct osdata
*threads
= get_osdata ("threads");
799 make_cleanup_osdata_free (threads
);
800 tree
= splay_tree_new (splay_tree_int_comparator
,
802 free_vector_of_osdata_items
);
803 make_cleanup (free_splay_tree
, tree
);
806 VEC_iterate (osdata_item_s
, threads
->items
,
810 const char *pid
= get_osdata_column (item
, "pid");
811 int pid_i
= strtoul (pid
, NULL
, 0);
812 VEC (osdata_item_s
) *vec
= 0;
814 splay_tree_node n
= splay_tree_lookup (tree
, pid_i
);
817 VEC_safe_push (osdata_item_s
, vec
, item
);
818 splay_tree_insert (tree
, pid_i
, (splay_tree_value
)vec
);
822 vec
= (VEC (osdata_item_s
) *) n
->value
;
823 VEC_safe_push (osdata_item_s
, vec
, item
);
824 n
->value
= (splay_tree_value
) vec
;
829 make_cleanup_ui_out_list_begin_end (uiout
, "groups");
832 VEC_iterate (osdata_item_s
, data
->items
,
836 struct cleanup
*back_to
;
838 const char *pid
= get_osdata_column (item
, "pid");
839 const char *cmd
= get_osdata_column (item
, "command");
840 const char *user
= get_osdata_column (item
, "user");
841 const char *cores
= get_osdata_column (item
, "cores");
843 int pid_i
= strtoul (pid
, NULL
, 0);
845 /* At present, the target will return all available processes
846 and if information about specific ones was required, we filter
847 undesired processes here. */
848 if (ids
&& bsearch (&pid_i
, VEC_address (int, ids
),
849 VEC_length (int, ids
),
850 sizeof (int), compare_positive_ints
) == NULL
)
854 back_to
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
856 uiout
->field_fmt ("id", "%s", pid
);
857 uiout
->field_string ("type", "process");
859 uiout
->field_string ("description", cmd
);
861 uiout
->field_string ("user", user
);
863 output_cores (uiout
, "cores", cores
);
867 splay_tree_node n
= splay_tree_lookup (tree
, pid_i
);
870 VEC (osdata_item_s
) *children
= (VEC (osdata_item_s
) *) n
->value
;
871 struct osdata_item
*child
;
874 make_cleanup_ui_out_list_begin_end (uiout
, "threads");
877 VEC_iterate (osdata_item_s
, children
, ix_child
, child
);
880 struct cleanup
*back_to_2
=
881 make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
882 const char *tid
= get_osdata_column (child
, "tid");
883 const char *tcore
= get_osdata_column (child
, "core");
885 uiout
->field_string ("id", tid
);
887 uiout
->field_string ("core", tcore
);
889 do_cleanups (back_to_2
);
894 do_cleanups (back_to
);
897 do_cleanups (cleanup
);
901 mi_cmd_list_thread_groups (char *command
, char **argv
, int argc
)
903 struct ui_out
*uiout
= current_uiout
;
904 struct cleanup
*back_to
;
911 AVAILABLE_OPT
, RECURSE_OPT
913 static const struct mi_opt opts
[] =
915 {"-available", AVAILABLE_OPT
, 0},
916 {"-recurse", RECURSE_OPT
, 1},
925 int opt
= mi_getopt ("-list-thread-groups", argc
, argv
, opts
,
930 switch ((enum opt
) opt
)
936 if (strcmp (oarg
, "0") == 0)
938 else if (strcmp (oarg
, "1") == 0)
941 error (_("only '0' and '1' are valid values "
942 "for the '--recurse' option"));
947 for (; oind
< argc
; ++oind
)
952 if (*(argv
[oind
]) != 'i')
953 error (_("invalid syntax of group id '%s'"), argv
[oind
]);
955 inf
= strtoul (argv
[oind
] + 1, &end
, 0);
958 error (_("invalid syntax of group id '%s'"), argv
[oind
]);
959 VEC_safe_push (int, ids
, inf
);
961 if (VEC_length (int, ids
) > 1)
962 qsort (VEC_address (int, ids
),
963 VEC_length (int, ids
),
964 sizeof (int), compare_positive_ints
);
966 back_to
= make_cleanup (free_vector_of_ints
, &ids
);
970 list_available_thread_groups (ids
, recurse
);
972 else if (VEC_length (int, ids
) == 1)
974 /* Local thread groups, single id. */
975 int id
= *VEC_address (int, ids
);
976 struct inferior
*inf
= find_inferior_id (id
);
979 error (_("Non-existent thread group id '%d'"), id
);
981 print_thread_info (uiout
, NULL
, inf
->pid
);
985 struct print_one_inferior_data data
;
987 data
.recurse
= recurse
;
988 data
.inferiors
= ids
;
990 /* Local thread groups. Either no explicit ids -- and we
991 print everything, or several explicit ids. In both cases,
992 we print more than one group, and have to use 'groups'
993 as the top-level element. */
994 make_cleanup_ui_out_list_begin_end (uiout
, "groups");
995 update_thread_list ();
996 iterate_over_inferiors (print_one_inferior
, &data
);
999 do_cleanups (back_to
);
1003 mi_cmd_data_list_register_names (char *command
, char **argv
, int argc
)
1005 struct gdbarch
*gdbarch
;
1006 struct ui_out
*uiout
= current_uiout
;
1007 int regnum
, numregs
;
1009 struct cleanup
*cleanup
;
1011 /* Note that the test for a valid register must include checking the
1012 gdbarch_register_name because gdbarch_num_regs may be allocated
1013 for the union of the register sets within a family of related
1014 processors. In this case, some entries of gdbarch_register_name
1015 will change depending upon the particular processor being
1018 gdbarch
= get_current_arch ();
1019 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1021 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "register-names");
1023 if (argc
== 0) /* No args, just do all the regs. */
1029 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1030 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1031 uiout
->field_string (NULL
, "");
1033 uiout
->field_string (NULL
, gdbarch_register_name (gdbarch
, regnum
));
1037 /* Else, list of register #s, just do listed regs. */
1038 for (i
= 0; i
< argc
; i
++)
1040 regnum
= atoi (argv
[i
]);
1041 if (regnum
< 0 || regnum
>= numregs
)
1042 error (_("bad register number"));
1044 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1045 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1046 uiout
->field_string (NULL
, "");
1048 uiout
->field_string (NULL
, gdbarch_register_name (gdbarch
, regnum
));
1050 do_cleanups (cleanup
);
1054 mi_cmd_data_list_changed_registers (char *command
, char **argv
, int argc
)
1056 static struct regcache
*this_regs
= NULL
;
1057 struct ui_out
*uiout
= current_uiout
;
1058 struct regcache
*prev_regs
;
1059 struct gdbarch
*gdbarch
;
1060 int regnum
, numregs
, changed
;
1062 struct cleanup
*cleanup
;
1064 /* The last time we visited this function, the current frame's
1065 register contents were saved in THIS_REGS. Move THIS_REGS over
1066 to PREV_REGS, and refresh THIS_REGS with the now-current register
1069 prev_regs
= this_regs
;
1070 this_regs
= frame_save_as_regcache (get_selected_frame (NULL
));
1071 cleanup
= make_cleanup_regcache_xfree (prev_regs
);
1073 /* Note that the test for a valid register must include checking the
1074 gdbarch_register_name because gdbarch_num_regs may be allocated
1075 for the union of the register sets within a family of related
1076 processors. In this case, some entries of gdbarch_register_name
1077 will change depending upon the particular processor being
1080 gdbarch
= get_regcache_arch (this_regs
);
1081 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1083 make_cleanup_ui_out_list_begin_end (uiout
, "changed-registers");
1087 /* No args, just do all the regs. */
1092 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1093 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1095 changed
= register_changed_p (regnum
, prev_regs
, this_regs
);
1097 error (_("-data-list-changed-registers: "
1098 "Unable to read register contents."));
1100 uiout
->field_int (NULL
, regnum
);
1104 /* Else, list of register #s, just do listed regs. */
1105 for (i
= 0; i
< argc
; i
++)
1107 regnum
= atoi (argv
[i
]);
1111 && gdbarch_register_name (gdbarch
, regnum
) != NULL
1112 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
1114 changed
= register_changed_p (regnum
, prev_regs
, this_regs
);
1116 error (_("-data-list-changed-registers: "
1117 "Unable to read register contents."));
1119 uiout
->field_int (NULL
, regnum
);
1122 error (_("bad register number"));
1124 do_cleanups (cleanup
);
1128 register_changed_p (int regnum
, struct regcache
*prev_regs
,
1129 struct regcache
*this_regs
)
1131 struct gdbarch
*gdbarch
= get_regcache_arch (this_regs
);
1132 gdb_byte prev_buffer
[MAX_REGISTER_SIZE
];
1133 gdb_byte this_buffer
[MAX_REGISTER_SIZE
];
1134 enum register_status prev_status
;
1135 enum register_status this_status
;
1137 /* First time through or after gdbarch change consider all registers
1139 if (!prev_regs
|| get_regcache_arch (prev_regs
) != gdbarch
)
1142 /* Get register contents and compare. */
1143 prev_status
= regcache_cooked_read (prev_regs
, regnum
, prev_buffer
);
1144 this_status
= regcache_cooked_read (this_regs
, regnum
, this_buffer
);
1146 if (this_status
!= prev_status
)
1148 else if (this_status
== REG_VALID
)
1149 return memcmp (prev_buffer
, this_buffer
,
1150 register_size (gdbarch
, regnum
)) != 0;
1155 /* Return a list of register number and value pairs. The valid
1156 arguments expected are: a letter indicating the format in which to
1157 display the registers contents. This can be one of: x
1158 (hexadecimal), d (decimal), N (natural), t (binary), o (octal), r
1159 (raw). After the format argument there can be a sequence of
1160 numbers, indicating which registers to fetch the content of. If
1161 the format is the only argument, a list of all the registers with
1162 their values is returned. */
1165 mi_cmd_data_list_register_values (char *command
, char **argv
, int argc
)
1167 struct ui_out
*uiout
= current_uiout
;
1168 struct frame_info
*frame
;
1169 struct gdbarch
*gdbarch
;
1170 int regnum
, numregs
, format
;
1172 struct cleanup
*list_cleanup
;
1173 int skip_unavailable
= 0;
1179 static const struct mi_opt opts
[] =
1181 {"-skip-unavailable", SKIP_UNAVAILABLE
, 0},
1185 /* Note that the test for a valid register must include checking the
1186 gdbarch_register_name because gdbarch_num_regs may be allocated
1187 for the union of the register sets within a family of related
1188 processors. In this case, some entries of gdbarch_register_name
1189 will change depending upon the particular processor being
1195 int opt
= mi_getopt ("-data-list-register-values", argc
, argv
,
1196 opts
, &oind
, &oarg
);
1200 switch ((enum opt
) opt
)
1202 case SKIP_UNAVAILABLE
:
1203 skip_unavailable
= 1;
1208 if (argc
- oind
< 1)
1209 error (_("-data-list-register-values: Usage: "
1210 "-data-list-register-values [--skip-unavailable] <format>"
1211 " [<regnum1>...<regnumN>]"));
1213 format
= (int) argv
[oind
][0];
1215 frame
= get_selected_frame (NULL
);
1216 gdbarch
= get_frame_arch (frame
);
1217 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1219 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "register-values");
1221 if (argc
- oind
== 1)
1223 /* No args, beside the format: do all the regs. */
1228 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1229 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1232 output_register (frame
, regnum
, format
, skip_unavailable
);
1236 /* Else, list of register #s, just do listed regs. */
1237 for (i
= 1 + oind
; i
< argc
; i
++)
1239 regnum
= atoi (argv
[i
]);
1243 && gdbarch_register_name (gdbarch
, regnum
) != NULL
1244 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
1245 output_register (frame
, regnum
, format
, skip_unavailable
);
1247 error (_("bad register number"));
1249 do_cleanups (list_cleanup
);
1252 /* Output one register REGNUM's contents in the desired FORMAT. If
1253 SKIP_UNAVAILABLE is true, skip the register if it is
1257 output_register (struct frame_info
*frame
, int regnum
, int format
,
1258 int skip_unavailable
)
1260 struct ui_out
*uiout
= current_uiout
;
1261 struct value
*val
= value_of_register (regnum
, frame
);
1262 struct cleanup
*tuple_cleanup
;
1263 struct value_print_options opts
;
1264 struct ui_file
*stb
;
1266 if (skip_unavailable
&& !value_entirely_available (val
))
1269 tuple_cleanup
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1270 uiout
->field_int ("number", regnum
);
1278 stb
= mem_fileopen ();
1279 make_cleanup_ui_file_delete (stb
);
1281 get_formatted_print_options (&opts
, format
);
1283 val_print (value_type (val
),
1284 value_embedded_offset (val
), 0,
1285 stb
, 0, val
, &opts
, current_language
);
1286 uiout
->field_stream ("value", stb
);
1288 do_cleanups (tuple_cleanup
);
1291 /* Write given values into registers. The registers and values are
1292 given as pairs. The corresponding MI command is
1293 -data-write-register-values <format>
1294 [<regnum1> <value1>...<regnumN> <valueN>] */
1296 mi_cmd_data_write_register_values (char *command
, char **argv
, int argc
)
1298 struct regcache
*regcache
;
1299 struct gdbarch
*gdbarch
;
1302 /* Note that the test for a valid register must include checking the
1303 gdbarch_register_name because gdbarch_num_regs may be allocated
1304 for the union of the register sets within a family of related
1305 processors. In this case, some entries of gdbarch_register_name
1306 will change depending upon the particular processor being
1309 regcache
= get_current_regcache ();
1310 gdbarch
= get_regcache_arch (regcache
);
1311 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1314 error (_("-data-write-register-values: Usage: -data-write-register-"
1315 "values <format> [<regnum1> <value1>...<regnumN> <valueN>]"));
1317 if (!target_has_registers
)
1318 error (_("-data-write-register-values: No registers."));
1321 error (_("-data-write-register-values: No regs and values specified."));
1324 error (_("-data-write-register-values: "
1325 "Regs and vals are not in pairs."));
1327 for (i
= 1; i
< argc
; i
= i
+ 2)
1329 int regnum
= atoi (argv
[i
]);
1331 if (regnum
>= 0 && regnum
< numregs
1332 && gdbarch_register_name (gdbarch
, regnum
)
1333 && *gdbarch_register_name (gdbarch
, regnum
))
1337 /* Get the value as a number. */
1338 value
= parse_and_eval_address (argv
[i
+ 1]);
1340 /* Write it down. */
1341 regcache_cooked_write_signed (regcache
, regnum
, value
);
1344 error (_("bad register number"));
1348 /* Evaluate the value of the argument. The argument is an
1349 expression. If the expression contains spaces it needs to be
1350 included in double quotes. */
1353 mi_cmd_data_evaluate_expression (char *command
, char **argv
, int argc
)
1355 struct cleanup
*old_chain
;
1357 struct ui_file
*stb
;
1358 struct value_print_options opts
;
1359 struct ui_out
*uiout
= current_uiout
;
1361 stb
= mem_fileopen ();
1362 old_chain
= make_cleanup_ui_file_delete (stb
);
1365 error (_("-data-evaluate-expression: "
1366 "Usage: -data-evaluate-expression expression"));
1368 expression_up expr
= parse_expression (argv
[0]);
1370 val
= evaluate_expression (expr
.get ());
1372 /* Print the result of the expression evaluation. */
1373 get_user_print_options (&opts
);
1375 common_val_print (val
, stb
, 0, &opts
, current_language
);
1377 uiout
->field_stream ("value", stb
);
1379 do_cleanups (old_chain
);
1382 /* This is the -data-read-memory command.
1384 ADDR: start address of data to be dumped.
1385 WORD-FORMAT: a char indicating format for the ``word''. See
1387 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
1388 NR_ROW: Number of rows.
1389 NR_COL: The number of colums (words per row).
1390 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
1391 ASCHAR for unprintable characters.
1393 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
1394 displayes them. Returns:
1396 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
1399 The number of bytes read is SIZE*ROW*COL. */
1402 mi_cmd_data_read_memory (char *command
, char **argv
, int argc
)
1404 struct gdbarch
*gdbarch
= get_current_arch ();
1405 struct ui_out
*uiout
= current_uiout
;
1407 long total_bytes
, nr_cols
, nr_rows
;
1409 struct type
*word_type
;
1421 static const struct mi_opt opts
[] =
1423 {"o", OFFSET_OPT
, 1},
1429 int opt
= mi_getopt ("-data-read-memory", argc
, argv
, opts
,
1434 switch ((enum opt
) opt
)
1437 offset
= atol (oarg
);
1444 if (argc
< 5 || argc
> 6)
1445 error (_("-data-read-memory: Usage: "
1446 "ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR]."));
1448 /* Extract all the arguments. */
1450 /* Start address of the memory dump. */
1451 addr
= parse_and_eval_address (argv
[0]) + offset
;
1452 /* The format character to use when displaying a memory word. See
1453 the ``x'' command. */
1454 word_format
= argv
[1][0];
1455 /* The size of the memory word. */
1456 word_size
= atol (argv
[2]);
1460 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1464 word_type
= builtin_type (gdbarch
)->builtin_int16
;
1468 word_type
= builtin_type (gdbarch
)->builtin_int32
;
1472 word_type
= builtin_type (gdbarch
)->builtin_int64
;
1476 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1479 /* The number of rows. */
1480 nr_rows
= atol (argv
[3]);
1482 error (_("-data-read-memory: invalid number of rows."));
1484 /* Number of bytes per row. */
1485 nr_cols
= atol (argv
[4]);
1487 error (_("-data-read-memory: invalid number of columns."));
1489 /* The un-printable character when printing ascii. */
1495 /* Create a buffer and read it in. */
1496 total_bytes
= word_size
* nr_rows
* nr_cols
;
1498 std::unique_ptr
<gdb_byte
[]> mbuf (new gdb_byte
[total_bytes
]);
1500 /* Dispatch memory reads to the topmost target, not the flattened
1502 nr_bytes
= target_read (current_target
.beneath
,
1503 TARGET_OBJECT_MEMORY
, NULL
, mbuf
.get (),
1506 error (_("Unable to read memory."));
1508 /* Output the header information. */
1509 uiout
->field_core_addr ("addr", gdbarch
, addr
);
1510 uiout
->field_int ("nr-bytes", nr_bytes
);
1511 uiout
->field_int ("total-bytes", total_bytes
);
1512 uiout
->field_core_addr ("next-row", gdbarch
, addr
+ word_size
* nr_cols
);
1513 uiout
->field_core_addr ("prev-row", gdbarch
, addr
- word_size
* nr_cols
);
1514 uiout
->field_core_addr ("next-page", gdbarch
, addr
+ total_bytes
);
1515 uiout
->field_core_addr ("prev-page", gdbarch
, addr
- total_bytes
);
1517 /* Build the result as a two dimentional table. */
1519 struct ui_file
*stream
;
1520 struct cleanup
*cleanup_stream
;
1524 stream
= mem_fileopen ();
1525 cleanup_stream
= make_cleanup_ui_file_delete (stream
);
1527 make_cleanup_ui_out_list_begin_end (uiout
, "memory");
1528 for (row
= 0, row_byte
= 0;
1530 row
++, row_byte
+= nr_cols
* word_size
)
1534 struct cleanup
*cleanup_tuple
;
1535 struct cleanup
*cleanup_list_data
;
1536 struct value_print_options opts
;
1538 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1539 uiout
->field_core_addr ("addr", gdbarch
, addr
+ row_byte
);
1540 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr +
1542 cleanup_list_data
= make_cleanup_ui_out_list_begin_end (uiout
, "data");
1543 get_formatted_print_options (&opts
, word_format
);
1544 for (col
= 0, col_byte
= row_byte
;
1546 col
++, col_byte
+= word_size
)
1548 if (col_byte
+ word_size
> nr_bytes
)
1550 uiout
->field_string (NULL
, "N/A");
1554 ui_file_rewind (stream
);
1555 print_scalar_formatted (&mbuf
[col_byte
], word_type
, &opts
,
1556 word_asize
, stream
);
1557 uiout
->field_stream (NULL
, stream
);
1560 do_cleanups (cleanup_list_data
);
1565 ui_file_rewind (stream
);
1566 for (byte
= row_byte
;
1567 byte
< row_byte
+ word_size
* nr_cols
; byte
++)
1569 if (byte
>= nr_bytes
)
1570 fputc_unfiltered ('X', stream
);
1571 else if (mbuf
[byte
] < 32 || mbuf
[byte
] > 126)
1572 fputc_unfiltered (aschar
, stream
);
1574 fputc_unfiltered (mbuf
[byte
], stream
);
1576 uiout
->field_stream ("ascii", stream
);
1578 do_cleanups (cleanup_tuple
);
1580 do_cleanups (cleanup_stream
);
1585 mi_cmd_data_read_memory_bytes (char *command
, char **argv
, int argc
)
1587 struct gdbarch
*gdbarch
= get_current_arch ();
1588 struct ui_out
*uiout
= current_uiout
;
1589 struct cleanup
*cleanups
;
1592 memory_read_result_s
*read_result
;
1594 VEC(memory_read_result_s
) *result
;
1596 int unit_size
= gdbarch_addressable_memory_unit_size (gdbarch
);
1603 static const struct mi_opt opts
[] =
1605 {"o", OFFSET_OPT
, 1},
1611 int opt
= mi_getopt ("-data-read-memory-bytes", argc
, argv
, opts
,
1615 switch ((enum opt
) opt
)
1618 offset
= atol (oarg
);
1626 error (_("Usage: [ -o OFFSET ] ADDR LENGTH."));
1628 addr
= parse_and_eval_address (argv
[0]) + offset
;
1629 length
= atol (argv
[1]);
1631 result
= read_memory_robust (current_target
.beneath
, addr
, length
);
1633 cleanups
= make_cleanup (free_memory_read_result_vector
, &result
);
1635 if (VEC_length (memory_read_result_s
, result
) == 0)
1636 error (_("Unable to read memory."));
1638 make_cleanup_ui_out_list_begin_end (uiout
, "memory");
1640 VEC_iterate (memory_read_result_s
, result
, ix
, read_result
);
1643 struct cleanup
*t
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1648 uiout
->field_core_addr ("begin", gdbarch
, read_result
->begin
);
1649 uiout
->field_core_addr ("offset", gdbarch
, read_result
->begin
- addr
);
1650 uiout
->field_core_addr ("end", gdbarch
, read_result
->end
);
1652 alloc_len
= (read_result
->end
- read_result
->begin
) * 2 * unit_size
+ 1;
1653 data
= (char *) xmalloc (alloc_len
);
1655 for (i
= 0, p
= data
;
1656 i
< ((read_result
->end
- read_result
->begin
) * unit_size
);
1659 sprintf (p
, "%02x", read_result
->data
[i
]);
1661 uiout
->field_string ("contents", data
);
1665 do_cleanups (cleanups
);
1668 /* Implementation of the -data-write_memory command.
1670 COLUMN_OFFSET: optional argument. Must be preceded by '-o'. The
1671 offset from the beginning of the memory grid row where the cell to
1673 ADDR: start address of the row in the memory grid where the memory
1674 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
1675 the location to write to.
1676 FORMAT: a char indicating format for the ``word''. See
1678 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
1679 VALUE: value to be written into the memory address.
1681 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1686 mi_cmd_data_write_memory (char *command
, char **argv
, int argc
)
1688 struct gdbarch
*gdbarch
= get_current_arch ();
1689 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1692 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1693 enough when using a compiler other than GCC. */
1696 struct cleanup
*old_chain
;
1704 static const struct mi_opt opts
[] =
1706 {"o", OFFSET_OPT
, 1},
1712 int opt
= mi_getopt ("-data-write-memory", argc
, argv
, opts
,
1717 switch ((enum opt
) opt
)
1720 offset
= atol (oarg
);
1728 error (_("-data-write-memory: Usage: "
1729 "[-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE."));
1731 /* Extract all the arguments. */
1732 /* Start address of the memory dump. */
1733 addr
= parse_and_eval_address (argv
[0]);
1734 /* The size of the memory word. */
1735 word_size
= atol (argv
[2]);
1737 /* Calculate the real address of the write destination. */
1738 addr
+= (offset
* word_size
);
1740 /* Get the value as a number. */
1741 value
= parse_and_eval_address (argv
[3]);
1742 /* Get the value into an array. */
1743 buffer
= (gdb_byte
*) xmalloc (word_size
);
1744 old_chain
= make_cleanup (xfree
, buffer
);
1745 store_signed_integer (buffer
, word_size
, byte_order
, value
);
1746 /* Write it down to memory. */
1747 write_memory_with_notification (addr
, buffer
, word_size
);
1748 /* Free the buffer. */
1749 do_cleanups (old_chain
);
1752 /* Implementation of the -data-write-memory-bytes command.
1755 DATA: string of bytes to write at that address
1756 COUNT: number of bytes to be filled (decimal integer). */
1759 mi_cmd_data_write_memory_bytes (char *command
, char **argv
, int argc
)
1765 size_t len_hex
, len_bytes
, len_units
, i
, steps
, remaining_units
;
1766 long int count_units
;
1767 struct cleanup
*back_to
;
1770 if (argc
!= 2 && argc
!= 3)
1771 error (_("Usage: ADDR DATA [COUNT]."));
1773 addr
= parse_and_eval_address (argv
[0]);
1775 len_hex
= strlen (cdata
);
1776 unit_size
= gdbarch_addressable_memory_unit_size (get_current_arch ());
1778 if (len_hex
% (unit_size
* 2) != 0)
1779 error (_("Hex-encoded '%s' must represent an integral number of "
1780 "addressable memory units."),
1783 len_bytes
= len_hex
/ 2;
1784 len_units
= len_bytes
/ unit_size
;
1787 count_units
= strtoul (argv
[2], NULL
, 10);
1789 count_units
= len_units
;
1791 databuf
= XNEWVEC (gdb_byte
, len_bytes
);
1792 back_to
= make_cleanup (xfree
, databuf
);
1794 for (i
= 0; i
< len_bytes
; ++i
)
1797 if (sscanf (cdata
+ i
* 2, "%02x", &x
) != 1)
1798 error (_("Invalid argument"));
1799 databuf
[i
] = (gdb_byte
) x
;
1802 if (len_units
< count_units
)
1804 /* Pattern is made of less units than count:
1805 repeat pattern to fill memory. */
1806 data
= (gdb_byte
*) xmalloc (count_units
* unit_size
);
1807 make_cleanup (xfree
, data
);
1809 /* Number of times the pattern is entirely repeated. */
1810 steps
= count_units
/ len_units
;
1811 /* Number of remaining addressable memory units. */
1812 remaining_units
= count_units
% len_units
;
1813 for (i
= 0; i
< steps
; i
++)
1814 memcpy (data
+ i
* len_bytes
, databuf
, len_bytes
);
1816 if (remaining_units
> 0)
1817 memcpy (data
+ steps
* len_bytes
, databuf
,
1818 remaining_units
* unit_size
);
1822 /* Pattern is longer than or equal to count:
1823 just copy count addressable memory units. */
1827 write_memory_with_notification (addr
, data
, count_units
);
1829 do_cleanups (back_to
);
1833 mi_cmd_enable_timings (char *command
, char **argv
, int argc
)
1839 if (strcmp (argv
[0], "yes") == 0)
1841 else if (strcmp (argv
[0], "no") == 0)
1852 error (_("-enable-timings: Usage: %s {yes|no}"), command
);
1856 mi_cmd_list_features (char *command
, char **argv
, int argc
)
1860 struct cleanup
*cleanup
= NULL
;
1861 struct ui_out
*uiout
= current_uiout
;
1863 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "features");
1864 uiout
->field_string (NULL
, "frozen-varobjs");
1865 uiout
->field_string (NULL
, "pending-breakpoints");
1866 uiout
->field_string (NULL
, "thread-info");
1867 uiout
->field_string (NULL
, "data-read-memory-bytes");
1868 uiout
->field_string (NULL
, "breakpoint-notifications");
1869 uiout
->field_string (NULL
, "ada-task-info");
1870 uiout
->field_string (NULL
, "language-option");
1871 uiout
->field_string (NULL
, "info-gdb-mi-command");
1872 uiout
->field_string (NULL
, "undefined-command-error-code");
1873 uiout
->field_string (NULL
, "exec-run-start-option");
1875 if (ext_lang_initialized_p (get_ext_lang_defn (EXT_LANG_PYTHON
)))
1876 uiout
->field_string (NULL
, "python");
1878 do_cleanups (cleanup
);
1882 error (_("-list-features should be passed no arguments"));
1886 mi_cmd_list_target_features (char *command
, char **argv
, int argc
)
1890 struct cleanup
*cleanup
= NULL
;
1891 struct ui_out
*uiout
= current_uiout
;
1893 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "features");
1895 uiout
->field_string (NULL
, "async");
1896 if (target_can_execute_reverse
)
1897 uiout
->field_string (NULL
, "reverse");
1898 do_cleanups (cleanup
);
1902 error (_("-list-target-features should be passed no arguments"));
1906 mi_cmd_add_inferior (char *command
, char **argv
, int argc
)
1908 struct inferior
*inf
;
1911 error (_("-add-inferior should be passed no arguments"));
1913 inf
= add_inferior_with_spaces ();
1915 current_uiout
->field_fmt ("inferior", "i%d", inf
->num
);
1918 /* Callback used to find the first inferior other than the current
1922 get_other_inferior (struct inferior
*inf
, void *arg
)
1924 if (inf
== current_inferior ())
1931 mi_cmd_remove_inferior (char *command
, char **argv
, int argc
)
1934 struct inferior
*inf
;
1937 error (_("-remove-inferior should be passed a single argument"));
1939 if (sscanf (argv
[0], "i%d", &id
) != 1)
1940 error (_("the thread group id is syntactically invalid"));
1942 inf
= find_inferior_id (id
);
1944 error (_("the specified thread group does not exist"));
1947 error (_("cannot remove an active inferior"));
1949 if (inf
== current_inferior ())
1951 struct thread_info
*tp
= 0;
1952 struct inferior
*new_inferior
1953 = iterate_over_inferiors (get_other_inferior
, NULL
);
1955 if (new_inferior
== NULL
)
1956 error (_("Cannot remove last inferior"));
1958 set_current_inferior (new_inferior
);
1959 if (new_inferior
->pid
!= 0)
1960 tp
= any_thread_of_process (new_inferior
->pid
);
1961 switch_to_thread (tp
? tp
->ptid
: null_ptid
);
1962 set_current_program_space (new_inferior
->pspace
);
1965 delete_inferior (inf
);
1970 /* Execute a command within a safe environment.
1971 Return <0 for error; >=0 for ok.
1973 args->action will tell mi_execute_command what action
1974 to perfrom after the given command has executed (display/suppress
1975 prompt, display error). */
1978 captured_mi_execute_command (struct ui_out
*uiout
, struct mi_parse
*context
)
1980 struct mi_interp
*mi
= (struct mi_interp
*) interp_data (command_interp ());
1981 struct cleanup
*cleanup
;
1984 current_command_ts
= context
->cmd_start
;
1986 current_token
= xstrdup (context
->token
);
1987 cleanup
= make_cleanup (free_current_contents
, ¤t_token
);
1989 running_result_record_printed
= 0;
1991 switch (context
->op
)
1994 /* A MI command was read from the input stream. */
1996 /* FIXME: gdb_???? */
1997 fprintf_unfiltered (mi
->raw_stdout
,
1998 " token=`%s' command=`%s' args=`%s'\n",
1999 context
->token
, context
->command
, context
->args
);
2001 mi_cmd_execute (context
);
2003 /* Print the result if there were no errors.
2005 Remember that on the way out of executing a command, you have
2006 to directly use the mi_interp's uiout, since the command
2007 could have reset the interpreter, in which case the current
2008 uiout will most likely crash in the mi_out_* routines. */
2009 if (!running_result_record_printed
)
2011 fputs_unfiltered (context
->token
, mi
->raw_stdout
);
2012 /* There's no particularly good reason why target-connect results
2013 in not ^done. Should kill ^connected for MI3. */
2014 fputs_unfiltered (strcmp (context
->command
, "target-select") == 0
2015 ? "^connected" : "^done", mi
->raw_stdout
);
2016 mi_out_put (uiout
, mi
->raw_stdout
);
2017 mi_out_rewind (uiout
);
2018 mi_print_timing_maybe (mi
->raw_stdout
);
2019 fputs_unfiltered ("\n", mi
->raw_stdout
);
2022 /* The command does not want anything to be printed. In that
2023 case, the command probably should not have written anything
2024 to uiout, but in case it has written something, discard it. */
2025 mi_out_rewind (uiout
);
2032 /* A CLI command was read from the input stream. */
2033 /* This "feature" will be removed as soon as we have a
2034 complete set of mi commands. */
2035 /* Echo the command on the console. */
2036 fprintf_unfiltered (gdb_stdlog
, "%s\n", context
->command
);
2037 /* Call the "console" interpreter. */
2038 argv
[0] = INTERP_CONSOLE
;
2039 argv
[1] = context
->command
;
2040 mi_cmd_interpreter_exec ("-interpreter-exec", argv
, 2);
2042 /* If we changed interpreters, DON'T print out anything. */
2043 if (current_interp_named_p (INTERP_MI
)
2044 || current_interp_named_p (INTERP_MI1
)
2045 || current_interp_named_p (INTERP_MI2
)
2046 || current_interp_named_p (INTERP_MI3
))
2048 if (!running_result_record_printed
)
2050 fputs_unfiltered (context
->token
, mi
->raw_stdout
);
2051 fputs_unfiltered ("^done", mi
->raw_stdout
);
2052 mi_out_put (uiout
, mi
->raw_stdout
);
2053 mi_out_rewind (uiout
);
2054 mi_print_timing_maybe (mi
->raw_stdout
);
2055 fputs_unfiltered ("\n", mi
->raw_stdout
);
2058 mi_out_rewind (uiout
);
2064 do_cleanups (cleanup
);
2067 /* Print a gdb exception to the MI output stream. */
2070 mi_print_exception (const char *token
, struct gdb_exception exception
)
2072 struct mi_interp
*mi
2073 = (struct mi_interp
*) interp_data (current_interpreter ());
2075 fputs_unfiltered (token
, mi
->raw_stdout
);
2076 fputs_unfiltered ("^error,msg=\"", mi
->raw_stdout
);
2077 if (exception
.message
== NULL
)
2078 fputs_unfiltered ("unknown error", mi
->raw_stdout
);
2080 fputstr_unfiltered (exception
.message
, '"', mi
->raw_stdout
);
2081 fputs_unfiltered ("\"", mi
->raw_stdout
);
2083 switch (exception
.error
)
2085 case UNDEFINED_COMMAND_ERROR
:
2086 fputs_unfiltered (",code=\"undefined-command\"", mi
->raw_stdout
);
2090 fputs_unfiltered ("\n", mi
->raw_stdout
);
2093 /* Determine whether the parsed command already notifies the
2094 user_selected_context_changed observer. */
2097 command_notifies_uscc_observer (struct mi_parse
*command
)
2099 if (command
->op
== CLI_COMMAND
)
2101 /* CLI commands "thread" and "inferior" already send it. */
2102 return (strncmp (command
->command
, "thread ", 7) == 0
2103 || strncmp (command
->command
, "inferior ", 9) == 0);
2105 else /* MI_COMMAND */
2107 if (strcmp (command
->command
, "interpreter-exec") == 0
2108 && command
->argc
> 1)
2110 /* "thread" and "inferior" again, but through -interpreter-exec. */
2111 return (strncmp (command
->argv
[1], "thread ", 7) == 0
2112 || strncmp (command
->argv
[1], "inferior ", 9) == 0);
2116 /* -thread-select already sends it. */
2117 return strcmp (command
->command
, "thread-select") == 0;
2122 mi_execute_command (const char *cmd
, int from_tty
)
2125 struct mi_parse
*command
= NULL
;
2127 /* This is to handle EOF (^D). We just quit gdb. */
2128 /* FIXME: we should call some API function here. */
2130 quit_force (NULL
, from_tty
);
2132 target_log_command (cmd
);
2136 command
= mi_parse (cmd
, &token
);
2138 CATCH (exception
, RETURN_MASK_ALL
)
2140 mi_print_exception (token
, exception
);
2145 if (command
!= NULL
)
2147 ptid_t previous_ptid
= inferior_ptid
;
2148 struct cleanup
*cleanup
= make_cleanup (null_cleanup
, NULL
);
2150 command
->token
= token
;
2152 if (command
->cmd
!= NULL
&& command
->cmd
->suppress_notification
!= NULL
)
2154 make_cleanup_restore_integer (command
->cmd
->suppress_notification
);
2155 *command
->cmd
->suppress_notification
= 1;
2160 command
->cmd_start
= new mi_timestamp ();
2161 timestamp (command
->cmd_start
);
2166 captured_mi_execute_command (current_uiout
, command
);
2168 CATCH (result
, RETURN_MASK_ALL
)
2170 /* Like in start_event_loop, enable input and force display
2171 of the prompt. Otherwise, any command that calls
2172 async_disable_stdin, and then throws, will leave input
2174 async_enable_stdin ();
2175 current_ui
->prompt_state
= PROMPT_NEEDED
;
2177 /* The command execution failed and error() was called
2179 mi_print_exception (command
->token
, result
);
2180 mi_out_rewind (current_uiout
);
2184 bpstat_do_actions ();
2186 if (/* The notifications are only output when the top-level
2187 interpreter (specified on the command line) is MI. */
2188 interp_ui_out (top_level_interpreter ())->is_mi_like_p ()
2189 /* Don't try report anything if there are no threads --
2190 the program is dead. */
2191 && thread_count () != 0
2192 /* If the command already reports the thread change, no need to do it
2194 && !command_notifies_uscc_observer (command
))
2196 struct mi_interp
*mi
2197 = (struct mi_interp
*) top_level_interpreter_data ();
2198 int report_change
= 0;
2200 if (command
->thread
== -1)
2202 report_change
= (!ptid_equal (previous_ptid
, null_ptid
)
2203 && !ptid_equal (inferior_ptid
, previous_ptid
)
2204 && !ptid_equal (inferior_ptid
, null_ptid
));
2206 else if (!ptid_equal (inferior_ptid
, null_ptid
))
2208 struct thread_info
*ti
= inferior_thread ();
2210 report_change
= (ti
->global_num
!= command
->thread
);
2215 observer_notify_user_selected_context_changed
2216 (USER_SELECTED_THREAD
| USER_SELECTED_FRAME
);
2220 mi_parse_free (command
);
2222 do_cleanups (cleanup
);
2227 mi_cmd_execute (struct mi_parse
*parse
)
2229 struct cleanup
*cleanup
;
2231 cleanup
= prepare_execute_command ();
2233 if (parse
->all
&& parse
->thread_group
!= -1)
2234 error (_("Cannot specify --thread-group together with --all"));
2236 if (parse
->all
&& parse
->thread
!= -1)
2237 error (_("Cannot specify --thread together with --all"));
2239 if (parse
->thread_group
!= -1 && parse
->thread
!= -1)
2240 error (_("Cannot specify --thread together with --thread-group"));
2242 if (parse
->frame
!= -1 && parse
->thread
== -1)
2243 error (_("Cannot specify --frame without --thread"));
2245 if (parse
->thread_group
!= -1)
2247 struct inferior
*inf
= find_inferior_id (parse
->thread_group
);
2248 struct thread_info
*tp
= 0;
2251 error (_("Invalid thread group for the --thread-group option"));
2253 set_current_inferior (inf
);
2254 /* This behaviour means that if --thread-group option identifies
2255 an inferior with multiple threads, then a random one will be
2256 picked. This is not a problem -- frontend should always
2257 provide --thread if it wishes to operate on a specific
2260 tp
= any_live_thread_of_process (inf
->pid
);
2261 switch_to_thread (tp
? tp
->ptid
: null_ptid
);
2262 set_current_program_space (inf
->pspace
);
2265 if (parse
->thread
!= -1)
2267 struct thread_info
*tp
= find_thread_global_id (parse
->thread
);
2270 error (_("Invalid thread id: %d"), parse
->thread
);
2272 if (is_exited (tp
->ptid
))
2273 error (_("Thread id: %d has terminated"), parse
->thread
);
2275 switch_to_thread (tp
->ptid
);
2278 if (parse
->frame
!= -1)
2280 struct frame_info
*fid
;
2281 int frame
= parse
->frame
;
2283 fid
= find_relative_frame (get_current_frame (), &frame
);
2285 /* find_relative_frame was successful */
2288 error (_("Invalid frame id: %d"), frame
);
2291 if (parse
->language
!= language_unknown
)
2293 make_cleanup_restore_current_language ();
2294 set_language (parse
->language
);
2297 current_context
= parse
;
2299 if (parse
->cmd
->argv_func
!= NULL
)
2301 parse
->cmd
->argv_func (parse
->command
, parse
->argv
, parse
->argc
);
2303 else if (parse
->cmd
->cli
.cmd
!= 0)
2305 /* FIXME: DELETE THIS. */
2306 /* The operation is still implemented by a cli command. */
2307 /* Must be a synchronous one. */
2308 mi_execute_cli_command (parse
->cmd
->cli
.cmd
, parse
->cmd
->cli
.args_p
,
2313 /* FIXME: DELETE THIS. */
2314 struct ui_file
*stb
;
2316 stb
= mem_fileopen ();
2318 fputs_unfiltered ("Undefined mi command: ", stb
);
2319 fputstr_unfiltered (parse
->command
, '"', stb
);
2320 fputs_unfiltered (" (missing implementation)", stb
);
2322 make_cleanup_ui_file_delete (stb
);
2325 do_cleanups (cleanup
);
2328 /* FIXME: This is just a hack so we can get some extra commands going.
2329 We don't want to channel things through the CLI, but call libgdb directly.
2330 Use only for synchronous commands. */
2333 mi_execute_cli_command (const char *cmd
, int args_p
, const char *args
)
2337 struct cleanup
*old_cleanups
;
2341 run
= xstrprintf ("%s %s", cmd
, args
);
2343 run
= xstrdup (cmd
);
2345 /* FIXME: gdb_???? */
2346 fprintf_unfiltered (gdb_stdout
, "cli=%s run=%s\n",
2348 old_cleanups
= make_cleanup (xfree
, run
);
2349 execute_command (run
, 0 /* from_tty */ );
2350 do_cleanups (old_cleanups
);
2356 mi_execute_async_cli_command (char *cli_command
, char **argv
, int argc
)
2358 struct cleanup
*old_cleanups
;
2362 run
= xstrprintf ("%s %s&", cli_command
, argc
? *argv
: "");
2364 run
= xstrprintf ("%s %s", cli_command
, argc
? *argv
: "");
2365 old_cleanups
= make_cleanup (xfree
, run
);
2367 execute_command (run
, 0 /* from_tty */ );
2369 /* Do this before doing any printing. It would appear that some
2370 print code leaves garbage around in the buffer. */
2371 do_cleanups (old_cleanups
);
2375 mi_load_progress (const char *section_name
,
2376 unsigned long sent_so_far
,
2377 unsigned long total_section
,
2378 unsigned long total_sent
,
2379 unsigned long grand_total
)
2381 using namespace std::chrono
;
2382 static steady_clock::time_point last_update
;
2383 static char *previous_sect_name
= NULL
;
2385 struct ui_out
*saved_uiout
;
2386 struct ui_out
*uiout
;
2387 struct mi_interp
*mi
2388 = (struct mi_interp
*) interp_data (current_interpreter ());
2390 /* This function is called through deprecated_show_load_progress
2391 which means uiout may not be correct. Fix it for the duration
2392 of this function. */
2393 saved_uiout
= current_uiout
;
2395 if (current_interp_named_p (INTERP_MI
)
2396 || current_interp_named_p (INTERP_MI2
))
2397 current_uiout
= mi_out_new (2);
2398 else if (current_interp_named_p (INTERP_MI1
))
2399 current_uiout
= mi_out_new (1);
2400 else if (current_interp_named_p (INTERP_MI3
))
2401 current_uiout
= mi_out_new (3);
2405 uiout
= current_uiout
;
2407 new_section
= (previous_sect_name
?
2408 strcmp (previous_sect_name
, section_name
) : 1);
2411 struct cleanup
*cleanup_tuple
;
2413 xfree (previous_sect_name
);
2414 previous_sect_name
= xstrdup (section_name
);
2417 fputs_unfiltered (current_token
, mi
->raw_stdout
);
2418 fputs_unfiltered ("+download", mi
->raw_stdout
);
2419 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2420 uiout
->field_string ("section", section_name
);
2421 uiout
->field_int ("section-size", total_section
);
2422 uiout
->field_int ("total-size", grand_total
);
2423 do_cleanups (cleanup_tuple
);
2424 mi_out_put (uiout
, mi
->raw_stdout
);
2425 fputs_unfiltered ("\n", mi
->raw_stdout
);
2426 gdb_flush (mi
->raw_stdout
);
2429 steady_clock::time_point time_now
= steady_clock::now ();
2430 if (time_now
- last_update
> milliseconds (500))
2432 struct cleanup
*cleanup_tuple
;
2434 last_update
= time_now
;
2436 fputs_unfiltered (current_token
, mi
->raw_stdout
);
2437 fputs_unfiltered ("+download", mi
->raw_stdout
);
2438 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2439 uiout
->field_string ("section", section_name
);
2440 uiout
->field_int ("section-sent", sent_so_far
);
2441 uiout
->field_int ("section-size", total_section
);
2442 uiout
->field_int ("total-sent", total_sent
);
2443 uiout
->field_int ("total-size", grand_total
);
2444 do_cleanups (cleanup_tuple
);
2445 mi_out_put (uiout
, mi
->raw_stdout
);
2446 fputs_unfiltered ("\n", mi
->raw_stdout
);
2447 gdb_flush (mi
->raw_stdout
);
2451 current_uiout
= saved_uiout
;
2455 timestamp (struct mi_timestamp
*tv
)
2457 using namespace std::chrono
;
2459 tv
->wallclock
= steady_clock::now ();
2460 run_time_clock::now (tv
->utime
, tv
->stime
);
2464 print_diff_now (struct ui_file
*file
, struct mi_timestamp
*start
)
2466 struct mi_timestamp now
;
2469 print_diff (file
, start
, &now
);
2473 mi_print_timing_maybe (struct ui_file
*file
)
2475 /* If the command is -enable-timing then do_timings may be true
2476 whilst current_command_ts is not initialized. */
2477 if (do_timings
&& current_command_ts
)
2478 print_diff_now (file
, current_command_ts
);
2482 print_diff (struct ui_file
*file
, struct mi_timestamp
*start
,
2483 struct mi_timestamp
*end
)
2485 using namespace std::chrono
;
2487 duration
<double> wallclock
= end
->wallclock
- start
->wallclock
;
2488 duration
<double> utime
= end
->utime
- start
->utime
;
2489 duration
<double> stime
= end
->stime
- start
->stime
;
2493 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
2494 wallclock
.count (), utime
.count (), stime
.count ());
2498 mi_cmd_trace_define_variable (char *command
, char **argv
, int argc
)
2500 LONGEST initval
= 0;
2501 struct trace_state_variable
*tsv
;
2504 if (argc
!= 1 && argc
!= 2)
2505 error (_("Usage: -trace-define-variable VARIABLE [VALUE]"));
2509 error (_("Name of trace variable should start with '$'"));
2511 validate_trace_state_variable_name (name
);
2513 tsv
= find_trace_state_variable (name
);
2515 tsv
= create_trace_state_variable (name
);
2518 initval
= value_as_long (parse_and_eval (argv
[1]));
2520 tsv
->initial_value
= initval
;
2524 mi_cmd_trace_list_variables (char *command
, char **argv
, int argc
)
2527 error (_("-trace-list-variables: no arguments allowed"));
2529 tvariables_info_1 ();
2533 mi_cmd_trace_find (char *command
, char **argv
, int argc
)
2538 error (_("trace selection mode is required"));
2542 if (strcmp (mode
, "none") == 0)
2544 tfind_1 (tfind_number
, -1, 0, 0, 0);
2548 check_trace_running (current_trace_status ());
2550 if (strcmp (mode
, "frame-number") == 0)
2553 error (_("frame number is required"));
2554 tfind_1 (tfind_number
, atoi (argv
[1]), 0, 0, 0);
2556 else if (strcmp (mode
, "tracepoint-number") == 0)
2559 error (_("tracepoint number is required"));
2560 tfind_1 (tfind_tp
, atoi (argv
[1]), 0, 0, 0);
2562 else if (strcmp (mode
, "pc") == 0)
2565 error (_("PC is required"));
2566 tfind_1 (tfind_pc
, 0, parse_and_eval_address (argv
[1]), 0, 0);
2568 else if (strcmp (mode
, "pc-inside-range") == 0)
2571 error (_("Start and end PC are required"));
2572 tfind_1 (tfind_range
, 0, parse_and_eval_address (argv
[1]),
2573 parse_and_eval_address (argv
[2]), 0);
2575 else if (strcmp (mode
, "pc-outside-range") == 0)
2578 error (_("Start and end PC are required"));
2579 tfind_1 (tfind_outside
, 0, parse_and_eval_address (argv
[1]),
2580 parse_and_eval_address (argv
[2]), 0);
2582 else if (strcmp (mode
, "line") == 0)
2584 struct symtabs_and_lines sals
;
2585 struct symtab_and_line sal
;
2586 static CORE_ADDR start_pc
, end_pc
;
2587 struct cleanup
*back_to
;
2590 error (_("Line is required"));
2592 sals
= decode_line_with_current_source (argv
[1],
2593 DECODE_LINE_FUNFIRSTLINE
);
2594 back_to
= make_cleanup (xfree
, sals
.sals
);
2598 if (sal
.symtab
== 0)
2599 error (_("Could not find the specified line"));
2601 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2602 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, 0);
2604 error (_("Could not find the specified line"));
2606 do_cleanups (back_to
);
2609 error (_("Invalid mode '%s'"), mode
);
2611 if (has_stack_frames () || get_traceframe_number () >= 0)
2612 print_stack_frame (get_selected_frame (NULL
), 1, LOC_AND_ADDRESS
, 1);
2616 mi_cmd_trace_save (char *command
, char **argv
, int argc
)
2618 int target_saves
= 0;
2619 int generate_ctf
= 0;
2626 TARGET_SAVE_OPT
, CTF_OPT
2628 static const struct mi_opt opts
[] =
2630 {"r", TARGET_SAVE_OPT
, 0},
2631 {"ctf", CTF_OPT
, 0},
2637 int opt
= mi_getopt ("-trace-save", argc
, argv
, opts
,
2642 switch ((enum opt
) opt
)
2644 case TARGET_SAVE_OPT
:
2653 if (argc
- oind
!= 1)
2654 error (_("Exactly one argument required "
2655 "(file in which to save trace data)"));
2657 filename
= argv
[oind
];
2660 trace_save_ctf (filename
, target_saves
);
2662 trace_save_tfile (filename
, target_saves
);
2666 mi_cmd_trace_start (char *command
, char **argv
, int argc
)
2668 start_tracing (NULL
);
2672 mi_cmd_trace_status (char *command
, char **argv
, int argc
)
2674 trace_status_mi (0);
2678 mi_cmd_trace_stop (char *command
, char **argv
, int argc
)
2680 stop_tracing (NULL
);
2681 trace_status_mi (1);
2684 /* Implement the "-ada-task-info" command. */
2687 mi_cmd_ada_task_info (char *command
, char **argv
, int argc
)
2689 if (argc
!= 0 && argc
!= 1)
2690 error (_("Invalid MI command"));
2692 print_ada_task_info (current_uiout
, argv
[0], current_inferior ());
2695 /* Print EXPRESSION according to VALUES. */
2698 print_variable_or_computed (const char *expression
, enum print_values values
)
2700 struct cleanup
*old_chain
;
2702 struct ui_file
*stb
;
2704 struct ui_out
*uiout
= current_uiout
;
2706 stb
= mem_fileopen ();
2707 old_chain
= make_cleanup_ui_file_delete (stb
);
2709 expression_up expr
= parse_expression (expression
);
2711 if (values
== PRINT_SIMPLE_VALUES
)
2712 val
= evaluate_type (expr
.get ());
2714 val
= evaluate_expression (expr
.get ());
2716 if (values
!= PRINT_NO_VALUES
)
2717 make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2718 uiout
->field_string ("name", expression
);
2722 case PRINT_SIMPLE_VALUES
:
2723 type
= check_typedef (value_type (val
));
2724 type_print (value_type (val
), "", stb
, -1);
2725 uiout
->field_stream ("type", stb
);
2726 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
2727 && TYPE_CODE (type
) != TYPE_CODE_STRUCT
2728 && TYPE_CODE (type
) != TYPE_CODE_UNION
)
2730 struct value_print_options opts
;
2732 get_no_prettyformat_print_options (&opts
);
2734 common_val_print (val
, stb
, 0, &opts
, current_language
);
2735 uiout
->field_stream ("value", stb
);
2738 case PRINT_ALL_VALUES
:
2740 struct value_print_options opts
;
2742 get_no_prettyformat_print_options (&opts
);
2744 common_val_print (val
, stb
, 0, &opts
, current_language
);
2745 uiout
->field_stream ("value", stb
);
2750 do_cleanups (old_chain
);
2753 /* Implement the "-trace-frame-collected" command. */
2756 mi_cmd_trace_frame_collected (char *command
, char **argv
, int argc
)
2758 struct cleanup
*old_chain
;
2759 struct bp_location
*tloc
;
2761 struct collection_list
*clist
;
2762 struct collection_list tracepoint_list
, stepping_list
;
2763 struct traceframe_info
*tinfo
;
2765 enum print_values var_print_values
= PRINT_ALL_VALUES
;
2766 enum print_values comp_print_values
= PRINT_ALL_VALUES
;
2767 int registers_format
= 'x';
2768 int memory_contents
= 0;
2769 struct ui_out
*uiout
= current_uiout
;
2777 static const struct mi_opt opts
[] =
2779 {"-var-print-values", VAR_PRINT_VALUES
, 1},
2780 {"-comp-print-values", COMP_PRINT_VALUES
, 1},
2781 {"-registers-format", REGISTERS_FORMAT
, 1},
2782 {"-memory-contents", MEMORY_CONTENTS
, 0},
2789 int opt
= mi_getopt ("-trace-frame-collected", argc
, argv
, opts
,
2793 switch ((enum opt
) opt
)
2795 case VAR_PRINT_VALUES
:
2796 var_print_values
= mi_parse_print_values (oarg
);
2798 case COMP_PRINT_VALUES
:
2799 comp_print_values
= mi_parse_print_values (oarg
);
2801 case REGISTERS_FORMAT
:
2802 registers_format
= oarg
[0];
2803 case MEMORY_CONTENTS
:
2804 memory_contents
= 1;
2810 error (_("Usage: -trace-frame-collected "
2811 "[--var-print-values PRINT_VALUES] "
2812 "[--comp-print-values PRINT_VALUES] "
2813 "[--registers-format FORMAT]"
2814 "[--memory-contents]"));
2816 /* This throws an error is not inspecting a trace frame. */
2817 tloc
= get_traceframe_location (&stepping_frame
);
2819 /* This command only makes sense for the current frame, not the
2821 old_chain
= make_cleanup_restore_current_thread ();
2822 select_frame (get_current_frame ());
2824 encode_actions (tloc
, &tracepoint_list
, &stepping_list
);
2827 clist
= &stepping_list
;
2829 clist
= &tracepoint_list
;
2831 tinfo
= get_traceframe_info ();
2833 /* Explicitly wholly collected variables. */
2835 struct cleanup
*list_cleanup
;
2838 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
,
2839 "explicit-variables");
2841 const std::vector
<std::string
> &wholly_collected
2842 = clist
->wholly_collected ();
2843 for (size_t i
= 0; i
< wholly_collected
.size (); i
++)
2845 const std::string
&str
= wholly_collected
[i
];
2846 print_variable_or_computed (str
.c_str (), var_print_values
);
2849 do_cleanups (list_cleanup
);
2852 /* Computed expressions. */
2854 struct cleanup
*list_cleanup
;
2859 = make_cleanup_ui_out_list_begin_end (uiout
,
2860 "computed-expressions");
2862 const std::vector
<std::string
> &computed
= clist
->computed ();
2863 for (size_t i
= 0; i
< computed
.size (); i
++)
2865 const std::string
&str
= computed
[i
];
2866 print_variable_or_computed (str
.c_str (), comp_print_values
);
2869 do_cleanups (list_cleanup
);
2872 /* Registers. Given pseudo-registers, and that some architectures
2873 (like MIPS) actually hide the raw registers, we don't go through
2874 the trace frame info, but instead consult the register cache for
2875 register availability. */
2877 struct cleanup
*list_cleanup
;
2878 struct frame_info
*frame
;
2879 struct gdbarch
*gdbarch
;
2883 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "registers");
2885 frame
= get_selected_frame (NULL
);
2886 gdbarch
= get_frame_arch (frame
);
2887 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
2889 for (regnum
= 0; regnum
< numregs
; regnum
++)
2891 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
2892 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
2895 output_register (frame
, regnum
, registers_format
, 1);
2898 do_cleanups (list_cleanup
);
2901 /* Trace state variables. */
2903 struct cleanup
*list_cleanup
;
2908 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "tvars");
2911 make_cleanup (free_current_contents
, &tsvname
);
2913 for (i
= 0; VEC_iterate (int, tinfo
->tvars
, i
, tvar
); i
++)
2915 struct cleanup
*cleanup_child
;
2916 struct trace_state_variable
*tsv
;
2918 tsv
= find_trace_state_variable_by_number (tvar
);
2920 cleanup_child
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2924 tsvname
= (char *) xrealloc (tsvname
, strlen (tsv
->name
) + 2);
2926 strcpy (tsvname
+ 1, tsv
->name
);
2927 uiout
->field_string ("name", tsvname
);
2929 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
2931 uiout
->field_int ("current", tsv
->value
);
2935 uiout
->field_skip ("name");
2936 uiout
->field_skip ("current");
2939 do_cleanups (cleanup_child
);
2942 do_cleanups (list_cleanup
);
2947 struct cleanup
*list_cleanup
;
2948 VEC(mem_range_s
) *available_memory
= NULL
;
2949 struct mem_range
*r
;
2952 traceframe_available_memory (&available_memory
, 0, ULONGEST_MAX
);
2953 make_cleanup (VEC_cleanup(mem_range_s
), &available_memory
);
2955 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "memory");
2957 for (i
= 0; VEC_iterate (mem_range_s
, available_memory
, i
, r
); i
++)
2959 struct cleanup
*cleanup_child
;
2961 struct gdbarch
*gdbarch
= target_gdbarch ();
2963 cleanup_child
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2965 uiout
->field_core_addr ("address", gdbarch
, r
->start
);
2966 uiout
->field_int ("length", r
->length
);
2968 data
= (gdb_byte
*) xmalloc (r
->length
);
2969 make_cleanup (xfree
, data
);
2971 if (memory_contents
)
2973 if (target_read_memory (r
->start
, data
, r
->length
) == 0)
2978 data_str
= (char *) xmalloc (r
->length
* 2 + 1);
2979 make_cleanup (xfree
, data_str
);
2981 for (m
= 0, p
= data_str
; m
< r
->length
; ++m
, p
+= 2)
2982 sprintf (p
, "%02x", data
[m
]);
2983 uiout
->field_string ("contents", data_str
);
2986 uiout
->field_skip ("contents");
2988 do_cleanups (cleanup_child
);
2991 do_cleanups (list_cleanup
);
2994 do_cleanups (old_chain
);
2998 _initialize_mi_main (void)
3000 struct cmd_list_element
*c
;
3002 add_setshow_boolean_cmd ("mi-async", class_run
,
3004 Set whether MI asynchronous mode is enabled."), _("\
3005 Show whether MI asynchronous mode is enabled."), _("\
3006 Tells GDB whether MI should be in asynchronous mode."),
3007 set_mi_async_command
,
3008 show_mi_async_command
,
3012 /* Alias old "target-async" to "mi-async". */
3013 c
= add_alias_cmd ("target-async", "mi-async", class_run
, 0, &setlist
);
3014 deprecate_cmd (c
, "set mi-async");
3015 c
= add_alias_cmd ("target-async", "mi-async", class_run
, 0, &showlist
);
3016 deprecate_cmd (c
, "show mi-async");