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 ui_out_field_fmt (uiout
, "id", "i%d", inferior
->num
);
669 ui_out_field_string (uiout
, "type", "process");
670 if (inferior
->has_exit_code
)
671 ui_out_field_string (uiout
, "exit-code",
672 int_string (inferior
->exit_code
, 8, 0, 0, 1));
673 if (inferior
->pid
!= 0)
674 ui_out_field_int (uiout
, "pid", inferior
->pid
);
676 if (inferior
->pspace
->pspace_exec_filename
!= NULL
)
678 ui_out_field_string (uiout
, "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 ui_out_field_int (uiout
, 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 ui_out_field_string (uiout
, 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 ui_out_field_fmt (uiout
, "id", "%s", pid
);
857 ui_out_field_string (uiout
, "type", "process");
859 ui_out_field_string (uiout
, "description", cmd
);
861 ui_out_field_string (uiout
, "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 ui_out_field_string (uiout
, "id", tid
);
887 ui_out_field_string (uiout
, "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 ui_out_field_string (uiout
, NULL
, "");
1033 ui_out_field_string (uiout
, NULL
,
1034 gdbarch_register_name (gdbarch
, regnum
));
1038 /* Else, list of register #s, just do listed regs. */
1039 for (i
= 0; i
< argc
; i
++)
1041 regnum
= atoi (argv
[i
]);
1042 if (regnum
< 0 || regnum
>= numregs
)
1043 error (_("bad register number"));
1045 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1046 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1047 ui_out_field_string (uiout
, NULL
, "");
1049 ui_out_field_string (uiout
, NULL
,
1050 gdbarch_register_name (gdbarch
, regnum
));
1052 do_cleanups (cleanup
);
1056 mi_cmd_data_list_changed_registers (char *command
, char **argv
, int argc
)
1058 static struct regcache
*this_regs
= NULL
;
1059 struct ui_out
*uiout
= current_uiout
;
1060 struct regcache
*prev_regs
;
1061 struct gdbarch
*gdbarch
;
1062 int regnum
, numregs
, changed
;
1064 struct cleanup
*cleanup
;
1066 /* The last time we visited this function, the current frame's
1067 register contents were saved in THIS_REGS. Move THIS_REGS over
1068 to PREV_REGS, and refresh THIS_REGS with the now-current register
1071 prev_regs
= this_regs
;
1072 this_regs
= frame_save_as_regcache (get_selected_frame (NULL
));
1073 cleanup
= make_cleanup_regcache_xfree (prev_regs
);
1075 /* Note that the test for a valid register must include checking the
1076 gdbarch_register_name because gdbarch_num_regs may be allocated
1077 for the union of the register sets within a family of related
1078 processors. In this case, some entries of gdbarch_register_name
1079 will change depending upon the particular processor being
1082 gdbarch
= get_regcache_arch (this_regs
);
1083 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1085 make_cleanup_ui_out_list_begin_end (uiout
, "changed-registers");
1089 /* No args, just do all the regs. */
1094 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1095 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1097 changed
= register_changed_p (regnum
, prev_regs
, this_regs
);
1099 error (_("-data-list-changed-registers: "
1100 "Unable to read register contents."));
1102 ui_out_field_int (uiout
, NULL
, regnum
);
1106 /* Else, list of register #s, just do listed regs. */
1107 for (i
= 0; i
< argc
; i
++)
1109 regnum
= atoi (argv
[i
]);
1113 && gdbarch_register_name (gdbarch
, regnum
) != NULL
1114 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
1116 changed
= register_changed_p (regnum
, prev_regs
, this_regs
);
1118 error (_("-data-list-changed-registers: "
1119 "Unable to read register contents."));
1121 ui_out_field_int (uiout
, NULL
, regnum
);
1124 error (_("bad register number"));
1126 do_cleanups (cleanup
);
1130 register_changed_p (int regnum
, struct regcache
*prev_regs
,
1131 struct regcache
*this_regs
)
1133 struct gdbarch
*gdbarch
= get_regcache_arch (this_regs
);
1134 gdb_byte prev_buffer
[MAX_REGISTER_SIZE
];
1135 gdb_byte this_buffer
[MAX_REGISTER_SIZE
];
1136 enum register_status prev_status
;
1137 enum register_status this_status
;
1139 /* First time through or after gdbarch change consider all registers
1141 if (!prev_regs
|| get_regcache_arch (prev_regs
) != gdbarch
)
1144 /* Get register contents and compare. */
1145 prev_status
= regcache_cooked_read (prev_regs
, regnum
, prev_buffer
);
1146 this_status
= regcache_cooked_read (this_regs
, regnum
, this_buffer
);
1148 if (this_status
!= prev_status
)
1150 else if (this_status
== REG_VALID
)
1151 return memcmp (prev_buffer
, this_buffer
,
1152 register_size (gdbarch
, regnum
)) != 0;
1157 /* Return a list of register number and value pairs. The valid
1158 arguments expected are: a letter indicating the format in which to
1159 display the registers contents. This can be one of: x
1160 (hexadecimal), d (decimal), N (natural), t (binary), o (octal), r
1161 (raw). After the format argument there can be a sequence of
1162 numbers, indicating which registers to fetch the content of. If
1163 the format is the only argument, a list of all the registers with
1164 their values is returned. */
1167 mi_cmd_data_list_register_values (char *command
, char **argv
, int argc
)
1169 struct ui_out
*uiout
= current_uiout
;
1170 struct frame_info
*frame
;
1171 struct gdbarch
*gdbarch
;
1172 int regnum
, numregs
, format
;
1174 struct cleanup
*list_cleanup
;
1175 int skip_unavailable
= 0;
1181 static const struct mi_opt opts
[] =
1183 {"-skip-unavailable", SKIP_UNAVAILABLE
, 0},
1187 /* Note that the test for a valid register must include checking the
1188 gdbarch_register_name because gdbarch_num_regs may be allocated
1189 for the union of the register sets within a family of related
1190 processors. In this case, some entries of gdbarch_register_name
1191 will change depending upon the particular processor being
1197 int opt
= mi_getopt ("-data-list-register-values", argc
, argv
,
1198 opts
, &oind
, &oarg
);
1202 switch ((enum opt
) opt
)
1204 case SKIP_UNAVAILABLE
:
1205 skip_unavailable
= 1;
1210 if (argc
- oind
< 1)
1211 error (_("-data-list-register-values: Usage: "
1212 "-data-list-register-values [--skip-unavailable] <format>"
1213 " [<regnum1>...<regnumN>]"));
1215 format
= (int) argv
[oind
][0];
1217 frame
= get_selected_frame (NULL
);
1218 gdbarch
= get_frame_arch (frame
);
1219 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1221 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "register-values");
1223 if (argc
- oind
== 1)
1225 /* No args, beside the format: do all the regs. */
1230 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1231 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1234 output_register (frame
, regnum
, format
, skip_unavailable
);
1238 /* Else, list of register #s, just do listed regs. */
1239 for (i
= 1 + oind
; i
< argc
; i
++)
1241 regnum
= atoi (argv
[i
]);
1245 && gdbarch_register_name (gdbarch
, regnum
) != NULL
1246 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
1247 output_register (frame
, regnum
, format
, skip_unavailable
);
1249 error (_("bad register number"));
1251 do_cleanups (list_cleanup
);
1254 /* Output one register REGNUM's contents in the desired FORMAT. If
1255 SKIP_UNAVAILABLE is true, skip the register if it is
1259 output_register (struct frame_info
*frame
, int regnum
, int format
,
1260 int skip_unavailable
)
1262 struct ui_out
*uiout
= current_uiout
;
1263 struct value
*val
= value_of_register (regnum
, frame
);
1264 struct cleanup
*tuple_cleanup
;
1265 struct value_print_options opts
;
1266 struct ui_file
*stb
;
1268 if (skip_unavailable
&& !value_entirely_available (val
))
1271 tuple_cleanup
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1272 ui_out_field_int (uiout
, "number", regnum
);
1280 stb
= mem_fileopen ();
1281 make_cleanup_ui_file_delete (stb
);
1283 get_formatted_print_options (&opts
, format
);
1285 val_print (value_type (val
),
1286 value_embedded_offset (val
), 0,
1287 stb
, 0, val
, &opts
, current_language
);
1288 ui_out_field_stream (uiout
, "value", stb
);
1290 do_cleanups (tuple_cleanup
);
1293 /* Write given values into registers. The registers and values are
1294 given as pairs. The corresponding MI command is
1295 -data-write-register-values <format>
1296 [<regnum1> <value1>...<regnumN> <valueN>] */
1298 mi_cmd_data_write_register_values (char *command
, char **argv
, int argc
)
1300 struct regcache
*regcache
;
1301 struct gdbarch
*gdbarch
;
1304 /* Note that the test for a valid register must include checking the
1305 gdbarch_register_name because gdbarch_num_regs may be allocated
1306 for the union of the register sets within a family of related
1307 processors. In this case, some entries of gdbarch_register_name
1308 will change depending upon the particular processor being
1311 regcache
= get_current_regcache ();
1312 gdbarch
= get_regcache_arch (regcache
);
1313 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1316 error (_("-data-write-register-values: Usage: -data-write-register-"
1317 "values <format> [<regnum1> <value1>...<regnumN> <valueN>]"));
1319 if (!target_has_registers
)
1320 error (_("-data-write-register-values: No registers."));
1323 error (_("-data-write-register-values: No regs and values specified."));
1326 error (_("-data-write-register-values: "
1327 "Regs and vals are not in pairs."));
1329 for (i
= 1; i
< argc
; i
= i
+ 2)
1331 int regnum
= atoi (argv
[i
]);
1333 if (regnum
>= 0 && regnum
< numregs
1334 && gdbarch_register_name (gdbarch
, regnum
)
1335 && *gdbarch_register_name (gdbarch
, regnum
))
1339 /* Get the value as a number. */
1340 value
= parse_and_eval_address (argv
[i
+ 1]);
1342 /* Write it down. */
1343 regcache_cooked_write_signed (regcache
, regnum
, value
);
1346 error (_("bad register number"));
1350 /* Evaluate the value of the argument. The argument is an
1351 expression. If the expression contains spaces it needs to be
1352 included in double quotes. */
1355 mi_cmd_data_evaluate_expression (char *command
, char **argv
, int argc
)
1357 struct cleanup
*old_chain
;
1359 struct ui_file
*stb
;
1360 struct value_print_options opts
;
1361 struct ui_out
*uiout
= current_uiout
;
1363 stb
= mem_fileopen ();
1364 old_chain
= make_cleanup_ui_file_delete (stb
);
1367 error (_("-data-evaluate-expression: "
1368 "Usage: -data-evaluate-expression expression"));
1370 expression_up expr
= parse_expression (argv
[0]);
1372 val
= evaluate_expression (expr
.get ());
1374 /* Print the result of the expression evaluation. */
1375 get_user_print_options (&opts
);
1377 common_val_print (val
, stb
, 0, &opts
, current_language
);
1379 ui_out_field_stream (uiout
, "value", stb
);
1381 do_cleanups (old_chain
);
1384 /* This is the -data-read-memory command.
1386 ADDR: start address of data to be dumped.
1387 WORD-FORMAT: a char indicating format for the ``word''. See
1389 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
1390 NR_ROW: Number of rows.
1391 NR_COL: The number of colums (words per row).
1392 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
1393 ASCHAR for unprintable characters.
1395 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
1396 displayes them. Returns:
1398 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
1401 The number of bytes read is SIZE*ROW*COL. */
1404 mi_cmd_data_read_memory (char *command
, char **argv
, int argc
)
1406 struct gdbarch
*gdbarch
= get_current_arch ();
1407 struct ui_out
*uiout
= current_uiout
;
1409 long total_bytes
, nr_cols
, nr_rows
;
1411 struct type
*word_type
;
1423 static const struct mi_opt opts
[] =
1425 {"o", OFFSET_OPT
, 1},
1431 int opt
= mi_getopt ("-data-read-memory", argc
, argv
, opts
,
1436 switch ((enum opt
) opt
)
1439 offset
= atol (oarg
);
1446 if (argc
< 5 || argc
> 6)
1447 error (_("-data-read-memory: Usage: "
1448 "ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR]."));
1450 /* Extract all the arguments. */
1452 /* Start address of the memory dump. */
1453 addr
= parse_and_eval_address (argv
[0]) + offset
;
1454 /* The format character to use when displaying a memory word. See
1455 the ``x'' command. */
1456 word_format
= argv
[1][0];
1457 /* The size of the memory word. */
1458 word_size
= atol (argv
[2]);
1462 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1466 word_type
= builtin_type (gdbarch
)->builtin_int16
;
1470 word_type
= builtin_type (gdbarch
)->builtin_int32
;
1474 word_type
= builtin_type (gdbarch
)->builtin_int64
;
1478 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1481 /* The number of rows. */
1482 nr_rows
= atol (argv
[3]);
1484 error (_("-data-read-memory: invalid number of rows."));
1486 /* Number of bytes per row. */
1487 nr_cols
= atol (argv
[4]);
1489 error (_("-data-read-memory: invalid number of columns."));
1491 /* The un-printable character when printing ascii. */
1497 /* Create a buffer and read it in. */
1498 total_bytes
= word_size
* nr_rows
* nr_cols
;
1500 std::unique_ptr
<gdb_byte
[]> mbuf (new gdb_byte
[total_bytes
]);
1502 /* Dispatch memory reads to the topmost target, not the flattened
1504 nr_bytes
= target_read (current_target
.beneath
,
1505 TARGET_OBJECT_MEMORY
, NULL
, mbuf
.get (),
1508 error (_("Unable to read memory."));
1510 /* Output the header information. */
1511 ui_out_field_core_addr (uiout
, "addr", gdbarch
, addr
);
1512 ui_out_field_int (uiout
, "nr-bytes", nr_bytes
);
1513 ui_out_field_int (uiout
, "total-bytes", total_bytes
);
1514 ui_out_field_core_addr (uiout
, "next-row",
1515 gdbarch
, addr
+ word_size
* nr_cols
);
1516 ui_out_field_core_addr (uiout
, "prev-row",
1517 gdbarch
, addr
- word_size
* nr_cols
);
1518 ui_out_field_core_addr (uiout
, "next-page", gdbarch
, addr
+ total_bytes
);
1519 ui_out_field_core_addr (uiout
, "prev-page", gdbarch
, addr
- total_bytes
);
1521 /* Build the result as a two dimentional table. */
1523 struct ui_file
*stream
;
1524 struct cleanup
*cleanup_stream
;
1528 stream
= mem_fileopen ();
1529 cleanup_stream
= make_cleanup_ui_file_delete (stream
);
1531 make_cleanup_ui_out_list_begin_end (uiout
, "memory");
1532 for (row
= 0, row_byte
= 0;
1534 row
++, row_byte
+= nr_cols
* word_size
)
1538 struct cleanup
*cleanup_tuple
;
1539 struct cleanup
*cleanup_list_data
;
1540 struct value_print_options opts
;
1542 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1543 ui_out_field_core_addr (uiout
, "addr", gdbarch
, addr
+ row_byte
);
1544 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr +
1546 cleanup_list_data
= make_cleanup_ui_out_list_begin_end (uiout
, "data");
1547 get_formatted_print_options (&opts
, word_format
);
1548 for (col
= 0, col_byte
= row_byte
;
1550 col
++, col_byte
+= word_size
)
1552 if (col_byte
+ word_size
> nr_bytes
)
1554 ui_out_field_string (uiout
, NULL
, "N/A");
1558 ui_file_rewind (stream
);
1559 print_scalar_formatted (&mbuf
[col_byte
], word_type
, &opts
,
1560 word_asize
, stream
);
1561 ui_out_field_stream (uiout
, NULL
, stream
);
1564 do_cleanups (cleanup_list_data
);
1569 ui_file_rewind (stream
);
1570 for (byte
= row_byte
;
1571 byte
< row_byte
+ word_size
* nr_cols
; byte
++)
1573 if (byte
>= nr_bytes
)
1574 fputc_unfiltered ('X', stream
);
1575 else if (mbuf
[byte
] < 32 || mbuf
[byte
] > 126)
1576 fputc_unfiltered (aschar
, stream
);
1578 fputc_unfiltered (mbuf
[byte
], stream
);
1580 ui_out_field_stream (uiout
, "ascii", stream
);
1582 do_cleanups (cleanup_tuple
);
1584 do_cleanups (cleanup_stream
);
1589 mi_cmd_data_read_memory_bytes (char *command
, char **argv
, int argc
)
1591 struct gdbarch
*gdbarch
= get_current_arch ();
1592 struct ui_out
*uiout
= current_uiout
;
1593 struct cleanup
*cleanups
;
1596 memory_read_result_s
*read_result
;
1598 VEC(memory_read_result_s
) *result
;
1600 int unit_size
= gdbarch_addressable_memory_unit_size (gdbarch
);
1607 static const struct mi_opt opts
[] =
1609 {"o", OFFSET_OPT
, 1},
1615 int opt
= mi_getopt ("-data-read-memory-bytes", argc
, argv
, opts
,
1619 switch ((enum opt
) opt
)
1622 offset
= atol (oarg
);
1630 error (_("Usage: [ -o OFFSET ] ADDR LENGTH."));
1632 addr
= parse_and_eval_address (argv
[0]) + offset
;
1633 length
= atol (argv
[1]);
1635 result
= read_memory_robust (current_target
.beneath
, addr
, length
);
1637 cleanups
= make_cleanup (free_memory_read_result_vector
, &result
);
1639 if (VEC_length (memory_read_result_s
, result
) == 0)
1640 error (_("Unable to read memory."));
1642 make_cleanup_ui_out_list_begin_end (uiout
, "memory");
1644 VEC_iterate (memory_read_result_s
, result
, ix
, read_result
);
1647 struct cleanup
*t
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1652 ui_out_field_core_addr (uiout
, "begin", gdbarch
, read_result
->begin
);
1653 ui_out_field_core_addr (uiout
, "offset", gdbarch
, read_result
->begin
1655 ui_out_field_core_addr (uiout
, "end", gdbarch
, read_result
->end
);
1657 alloc_len
= (read_result
->end
- read_result
->begin
) * 2 * unit_size
+ 1;
1658 data
= (char *) xmalloc (alloc_len
);
1660 for (i
= 0, p
= data
;
1661 i
< ((read_result
->end
- read_result
->begin
) * unit_size
);
1664 sprintf (p
, "%02x", read_result
->data
[i
]);
1666 ui_out_field_string (uiout
, "contents", data
);
1670 do_cleanups (cleanups
);
1673 /* Implementation of the -data-write_memory command.
1675 COLUMN_OFFSET: optional argument. Must be preceded by '-o'. The
1676 offset from the beginning of the memory grid row where the cell to
1678 ADDR: start address of the row in the memory grid where the memory
1679 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
1680 the location to write to.
1681 FORMAT: a char indicating format for the ``word''. See
1683 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
1684 VALUE: value to be written into the memory address.
1686 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1691 mi_cmd_data_write_memory (char *command
, char **argv
, int argc
)
1693 struct gdbarch
*gdbarch
= get_current_arch ();
1694 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1697 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1698 enough when using a compiler other than GCC. */
1701 struct cleanup
*old_chain
;
1709 static const struct mi_opt opts
[] =
1711 {"o", OFFSET_OPT
, 1},
1717 int opt
= mi_getopt ("-data-write-memory", argc
, argv
, opts
,
1722 switch ((enum opt
) opt
)
1725 offset
= atol (oarg
);
1733 error (_("-data-write-memory: Usage: "
1734 "[-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE."));
1736 /* Extract all the arguments. */
1737 /* Start address of the memory dump. */
1738 addr
= parse_and_eval_address (argv
[0]);
1739 /* The size of the memory word. */
1740 word_size
= atol (argv
[2]);
1742 /* Calculate the real address of the write destination. */
1743 addr
+= (offset
* word_size
);
1745 /* Get the value as a number. */
1746 value
= parse_and_eval_address (argv
[3]);
1747 /* Get the value into an array. */
1748 buffer
= (gdb_byte
*) xmalloc (word_size
);
1749 old_chain
= make_cleanup (xfree
, buffer
);
1750 store_signed_integer (buffer
, word_size
, byte_order
, value
);
1751 /* Write it down to memory. */
1752 write_memory_with_notification (addr
, buffer
, word_size
);
1753 /* Free the buffer. */
1754 do_cleanups (old_chain
);
1757 /* Implementation of the -data-write-memory-bytes command.
1760 DATA: string of bytes to write at that address
1761 COUNT: number of bytes to be filled (decimal integer). */
1764 mi_cmd_data_write_memory_bytes (char *command
, char **argv
, int argc
)
1770 size_t len_hex
, len_bytes
, len_units
, i
, steps
, remaining_units
;
1771 long int count_units
;
1772 struct cleanup
*back_to
;
1775 if (argc
!= 2 && argc
!= 3)
1776 error (_("Usage: ADDR DATA [COUNT]."));
1778 addr
= parse_and_eval_address (argv
[0]);
1780 len_hex
= strlen (cdata
);
1781 unit_size
= gdbarch_addressable_memory_unit_size (get_current_arch ());
1783 if (len_hex
% (unit_size
* 2) != 0)
1784 error (_("Hex-encoded '%s' must represent an integral number of "
1785 "addressable memory units."),
1788 len_bytes
= len_hex
/ 2;
1789 len_units
= len_bytes
/ unit_size
;
1792 count_units
= strtoul (argv
[2], NULL
, 10);
1794 count_units
= len_units
;
1796 databuf
= XNEWVEC (gdb_byte
, len_bytes
);
1797 back_to
= make_cleanup (xfree
, databuf
);
1799 for (i
= 0; i
< len_bytes
; ++i
)
1802 if (sscanf (cdata
+ i
* 2, "%02x", &x
) != 1)
1803 error (_("Invalid argument"));
1804 databuf
[i
] = (gdb_byte
) x
;
1807 if (len_units
< count_units
)
1809 /* Pattern is made of less units than count:
1810 repeat pattern to fill memory. */
1811 data
= (gdb_byte
*) xmalloc (count_units
* unit_size
);
1812 make_cleanup (xfree
, data
);
1814 /* Number of times the pattern is entirely repeated. */
1815 steps
= count_units
/ len_units
;
1816 /* Number of remaining addressable memory units. */
1817 remaining_units
= count_units
% len_units
;
1818 for (i
= 0; i
< steps
; i
++)
1819 memcpy (data
+ i
* len_bytes
, databuf
, len_bytes
);
1821 if (remaining_units
> 0)
1822 memcpy (data
+ steps
* len_bytes
, databuf
,
1823 remaining_units
* unit_size
);
1827 /* Pattern is longer than or equal to count:
1828 just copy count addressable memory units. */
1832 write_memory_with_notification (addr
, data
, count_units
);
1834 do_cleanups (back_to
);
1838 mi_cmd_enable_timings (char *command
, char **argv
, int argc
)
1844 if (strcmp (argv
[0], "yes") == 0)
1846 else if (strcmp (argv
[0], "no") == 0)
1857 error (_("-enable-timings: Usage: %s {yes|no}"), command
);
1861 mi_cmd_list_features (char *command
, char **argv
, int argc
)
1865 struct cleanup
*cleanup
= NULL
;
1866 struct ui_out
*uiout
= current_uiout
;
1868 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "features");
1869 ui_out_field_string (uiout
, NULL
, "frozen-varobjs");
1870 ui_out_field_string (uiout
, NULL
, "pending-breakpoints");
1871 ui_out_field_string (uiout
, NULL
, "thread-info");
1872 ui_out_field_string (uiout
, NULL
, "data-read-memory-bytes");
1873 ui_out_field_string (uiout
, NULL
, "breakpoint-notifications");
1874 ui_out_field_string (uiout
, NULL
, "ada-task-info");
1875 ui_out_field_string (uiout
, NULL
, "language-option");
1876 ui_out_field_string (uiout
, NULL
, "info-gdb-mi-command");
1877 ui_out_field_string (uiout
, NULL
, "undefined-command-error-code");
1878 ui_out_field_string (uiout
, NULL
, "exec-run-start-option");
1880 if (ext_lang_initialized_p (get_ext_lang_defn (EXT_LANG_PYTHON
)))
1881 ui_out_field_string (uiout
, NULL
, "python");
1883 do_cleanups (cleanup
);
1887 error (_("-list-features should be passed no arguments"));
1891 mi_cmd_list_target_features (char *command
, char **argv
, int argc
)
1895 struct cleanup
*cleanup
= NULL
;
1896 struct ui_out
*uiout
= current_uiout
;
1898 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "features");
1900 ui_out_field_string (uiout
, NULL
, "async");
1901 if (target_can_execute_reverse
)
1902 ui_out_field_string (uiout
, NULL
, "reverse");
1903 do_cleanups (cleanup
);
1907 error (_("-list-target-features should be passed no arguments"));
1911 mi_cmd_add_inferior (char *command
, char **argv
, int argc
)
1913 struct inferior
*inf
;
1916 error (_("-add-inferior should be passed no arguments"));
1918 inf
= add_inferior_with_spaces ();
1920 ui_out_field_fmt (current_uiout
, "inferior", "i%d", inf
->num
);
1923 /* Callback used to find the first inferior other than the current
1927 get_other_inferior (struct inferior
*inf
, void *arg
)
1929 if (inf
== current_inferior ())
1936 mi_cmd_remove_inferior (char *command
, char **argv
, int argc
)
1939 struct inferior
*inf
;
1942 error (_("-remove-inferior should be passed a single argument"));
1944 if (sscanf (argv
[0], "i%d", &id
) != 1)
1945 error (_("the thread group id is syntactically invalid"));
1947 inf
= find_inferior_id (id
);
1949 error (_("the specified thread group does not exist"));
1952 error (_("cannot remove an active inferior"));
1954 if (inf
== current_inferior ())
1956 struct thread_info
*tp
= 0;
1957 struct inferior
*new_inferior
1958 = iterate_over_inferiors (get_other_inferior
, NULL
);
1960 if (new_inferior
== NULL
)
1961 error (_("Cannot remove last inferior"));
1963 set_current_inferior (new_inferior
);
1964 if (new_inferior
->pid
!= 0)
1965 tp
= any_thread_of_process (new_inferior
->pid
);
1966 switch_to_thread (tp
? tp
->ptid
: null_ptid
);
1967 set_current_program_space (new_inferior
->pspace
);
1970 delete_inferior (inf
);
1975 /* Execute a command within a safe environment.
1976 Return <0 for error; >=0 for ok.
1978 args->action will tell mi_execute_command what action
1979 to perfrom after the given command has executed (display/suppress
1980 prompt, display error). */
1983 captured_mi_execute_command (struct ui_out
*uiout
, struct mi_parse
*context
)
1985 struct mi_interp
*mi
= (struct mi_interp
*) interp_data (command_interp ());
1986 struct cleanup
*cleanup
;
1989 current_command_ts
= context
->cmd_start
;
1991 current_token
= xstrdup (context
->token
);
1992 cleanup
= make_cleanup (free_current_contents
, ¤t_token
);
1994 running_result_record_printed
= 0;
1996 switch (context
->op
)
1999 /* A MI command was read from the input stream. */
2001 /* FIXME: gdb_???? */
2002 fprintf_unfiltered (mi
->raw_stdout
,
2003 " token=`%s' command=`%s' args=`%s'\n",
2004 context
->token
, context
->command
, context
->args
);
2006 mi_cmd_execute (context
);
2008 /* Print the result if there were no errors.
2010 Remember that on the way out of executing a command, you have
2011 to directly use the mi_interp's uiout, since the command
2012 could have reset the interpreter, in which case the current
2013 uiout will most likely crash in the mi_out_* routines. */
2014 if (!running_result_record_printed
)
2016 fputs_unfiltered (context
->token
, mi
->raw_stdout
);
2017 /* There's no particularly good reason why target-connect results
2018 in not ^done. Should kill ^connected for MI3. */
2019 fputs_unfiltered (strcmp (context
->command
, "target-select") == 0
2020 ? "^connected" : "^done", mi
->raw_stdout
);
2021 mi_out_put (uiout
, mi
->raw_stdout
);
2022 mi_out_rewind (uiout
);
2023 mi_print_timing_maybe (mi
->raw_stdout
);
2024 fputs_unfiltered ("\n", mi
->raw_stdout
);
2027 /* The command does not want anything to be printed. In that
2028 case, the command probably should not have written anything
2029 to uiout, but in case it has written something, discard it. */
2030 mi_out_rewind (uiout
);
2037 /* A CLI command was read from the input stream. */
2038 /* This "feature" will be removed as soon as we have a
2039 complete set of mi commands. */
2040 /* Echo the command on the console. */
2041 fprintf_unfiltered (gdb_stdlog
, "%s\n", context
->command
);
2042 /* Call the "console" interpreter. */
2043 argv
[0] = INTERP_CONSOLE
;
2044 argv
[1] = context
->command
;
2045 mi_cmd_interpreter_exec ("-interpreter-exec", argv
, 2);
2047 /* If we changed interpreters, DON'T print out anything. */
2048 if (current_interp_named_p (INTERP_MI
)
2049 || current_interp_named_p (INTERP_MI1
)
2050 || current_interp_named_p (INTERP_MI2
)
2051 || current_interp_named_p (INTERP_MI3
))
2053 if (!running_result_record_printed
)
2055 fputs_unfiltered (context
->token
, mi
->raw_stdout
);
2056 fputs_unfiltered ("^done", mi
->raw_stdout
);
2057 mi_out_put (uiout
, mi
->raw_stdout
);
2058 mi_out_rewind (uiout
);
2059 mi_print_timing_maybe (mi
->raw_stdout
);
2060 fputs_unfiltered ("\n", mi
->raw_stdout
);
2063 mi_out_rewind (uiout
);
2069 do_cleanups (cleanup
);
2072 /* Print a gdb exception to the MI output stream. */
2075 mi_print_exception (const char *token
, struct gdb_exception exception
)
2077 struct mi_interp
*mi
2078 = (struct mi_interp
*) interp_data (current_interpreter ());
2080 fputs_unfiltered (token
, mi
->raw_stdout
);
2081 fputs_unfiltered ("^error,msg=\"", mi
->raw_stdout
);
2082 if (exception
.message
== NULL
)
2083 fputs_unfiltered ("unknown error", mi
->raw_stdout
);
2085 fputstr_unfiltered (exception
.message
, '"', mi
->raw_stdout
);
2086 fputs_unfiltered ("\"", mi
->raw_stdout
);
2088 switch (exception
.error
)
2090 case UNDEFINED_COMMAND_ERROR
:
2091 fputs_unfiltered (",code=\"undefined-command\"", mi
->raw_stdout
);
2095 fputs_unfiltered ("\n", mi
->raw_stdout
);
2098 /* Determine whether the parsed command already notifies the
2099 user_selected_context_changed observer. */
2102 command_notifies_uscc_observer (struct mi_parse
*command
)
2104 if (command
->op
== CLI_COMMAND
)
2106 /* CLI commands "thread" and "inferior" already send it. */
2107 return (strncmp (command
->command
, "thread ", 7) == 0
2108 || strncmp (command
->command
, "inferior ", 9) == 0);
2110 else /* MI_COMMAND */
2112 if (strcmp (command
->command
, "interpreter-exec") == 0
2113 && command
->argc
> 1)
2115 /* "thread" and "inferior" again, but through -interpreter-exec. */
2116 return (strncmp (command
->argv
[1], "thread ", 7) == 0
2117 || strncmp (command
->argv
[1], "inferior ", 9) == 0);
2121 /* -thread-select already sends it. */
2122 return strcmp (command
->command
, "thread-select") == 0;
2127 mi_execute_command (const char *cmd
, int from_tty
)
2130 struct mi_parse
*command
= NULL
;
2132 /* This is to handle EOF (^D). We just quit gdb. */
2133 /* FIXME: we should call some API function here. */
2135 quit_force (NULL
, from_tty
);
2137 target_log_command (cmd
);
2141 command
= mi_parse (cmd
, &token
);
2143 CATCH (exception
, RETURN_MASK_ALL
)
2145 mi_print_exception (token
, exception
);
2150 if (command
!= NULL
)
2152 ptid_t previous_ptid
= inferior_ptid
;
2153 struct cleanup
*cleanup
= make_cleanup (null_cleanup
, NULL
);
2155 command
->token
= token
;
2157 if (command
->cmd
!= NULL
&& command
->cmd
->suppress_notification
!= NULL
)
2159 make_cleanup_restore_integer (command
->cmd
->suppress_notification
);
2160 *command
->cmd
->suppress_notification
= 1;
2165 command
->cmd_start
= new mi_timestamp ();
2166 timestamp (command
->cmd_start
);
2171 captured_mi_execute_command (current_uiout
, command
);
2173 CATCH (result
, RETURN_MASK_ALL
)
2175 /* Like in start_event_loop, enable input and force display
2176 of the prompt. Otherwise, any command that calls
2177 async_disable_stdin, and then throws, will leave input
2179 async_enable_stdin ();
2180 current_ui
->prompt_state
= PROMPT_NEEDED
;
2182 /* The command execution failed and error() was called
2184 mi_print_exception (command
->token
, result
);
2185 mi_out_rewind (current_uiout
);
2189 bpstat_do_actions ();
2191 if (/* The notifications are only output when the top-level
2192 interpreter (specified on the command line) is MI. */
2193 ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ()))
2194 /* Don't try report anything if there are no threads --
2195 the program is dead. */
2196 && thread_count () != 0
2197 /* If the command already reports the thread change, no need to do it
2199 && !command_notifies_uscc_observer (command
))
2201 struct mi_interp
*mi
2202 = (struct mi_interp
*) top_level_interpreter_data ();
2203 int report_change
= 0;
2205 if (command
->thread
== -1)
2207 report_change
= (!ptid_equal (previous_ptid
, null_ptid
)
2208 && !ptid_equal (inferior_ptid
, previous_ptid
)
2209 && !ptid_equal (inferior_ptid
, null_ptid
));
2211 else if (!ptid_equal (inferior_ptid
, null_ptid
))
2213 struct thread_info
*ti
= inferior_thread ();
2215 report_change
= (ti
->global_num
!= command
->thread
);
2220 observer_notify_user_selected_context_changed
2221 (USER_SELECTED_THREAD
| USER_SELECTED_FRAME
);
2225 mi_parse_free (command
);
2227 do_cleanups (cleanup
);
2232 mi_cmd_execute (struct mi_parse
*parse
)
2234 struct cleanup
*cleanup
;
2236 cleanup
= prepare_execute_command ();
2238 if (parse
->all
&& parse
->thread_group
!= -1)
2239 error (_("Cannot specify --thread-group together with --all"));
2241 if (parse
->all
&& parse
->thread
!= -1)
2242 error (_("Cannot specify --thread together with --all"));
2244 if (parse
->thread_group
!= -1 && parse
->thread
!= -1)
2245 error (_("Cannot specify --thread together with --thread-group"));
2247 if (parse
->frame
!= -1 && parse
->thread
== -1)
2248 error (_("Cannot specify --frame without --thread"));
2250 if (parse
->thread_group
!= -1)
2252 struct inferior
*inf
= find_inferior_id (parse
->thread_group
);
2253 struct thread_info
*tp
= 0;
2256 error (_("Invalid thread group for the --thread-group option"));
2258 set_current_inferior (inf
);
2259 /* This behaviour means that if --thread-group option identifies
2260 an inferior with multiple threads, then a random one will be
2261 picked. This is not a problem -- frontend should always
2262 provide --thread if it wishes to operate on a specific
2265 tp
= any_live_thread_of_process (inf
->pid
);
2266 switch_to_thread (tp
? tp
->ptid
: null_ptid
);
2267 set_current_program_space (inf
->pspace
);
2270 if (parse
->thread
!= -1)
2272 struct thread_info
*tp
= find_thread_global_id (parse
->thread
);
2275 error (_("Invalid thread id: %d"), parse
->thread
);
2277 if (is_exited (tp
->ptid
))
2278 error (_("Thread id: %d has terminated"), parse
->thread
);
2280 switch_to_thread (tp
->ptid
);
2283 if (parse
->frame
!= -1)
2285 struct frame_info
*fid
;
2286 int frame
= parse
->frame
;
2288 fid
= find_relative_frame (get_current_frame (), &frame
);
2290 /* find_relative_frame was successful */
2293 error (_("Invalid frame id: %d"), frame
);
2296 if (parse
->language
!= language_unknown
)
2298 make_cleanup_restore_current_language ();
2299 set_language (parse
->language
);
2302 current_context
= parse
;
2304 if (parse
->cmd
->argv_func
!= NULL
)
2306 parse
->cmd
->argv_func (parse
->command
, parse
->argv
, parse
->argc
);
2308 else if (parse
->cmd
->cli
.cmd
!= 0)
2310 /* FIXME: DELETE THIS. */
2311 /* The operation is still implemented by a cli command. */
2312 /* Must be a synchronous one. */
2313 mi_execute_cli_command (parse
->cmd
->cli
.cmd
, parse
->cmd
->cli
.args_p
,
2318 /* FIXME: DELETE THIS. */
2319 struct ui_file
*stb
;
2321 stb
= mem_fileopen ();
2323 fputs_unfiltered ("Undefined mi command: ", stb
);
2324 fputstr_unfiltered (parse
->command
, '"', stb
);
2325 fputs_unfiltered (" (missing implementation)", stb
);
2327 make_cleanup_ui_file_delete (stb
);
2330 do_cleanups (cleanup
);
2333 /* FIXME: This is just a hack so we can get some extra commands going.
2334 We don't want to channel things through the CLI, but call libgdb directly.
2335 Use only for synchronous commands. */
2338 mi_execute_cli_command (const char *cmd
, int args_p
, const char *args
)
2342 struct cleanup
*old_cleanups
;
2346 run
= xstrprintf ("%s %s", cmd
, args
);
2348 run
= xstrdup (cmd
);
2350 /* FIXME: gdb_???? */
2351 fprintf_unfiltered (gdb_stdout
, "cli=%s run=%s\n",
2353 old_cleanups
= make_cleanup (xfree
, run
);
2354 execute_command (run
, 0 /* from_tty */ );
2355 do_cleanups (old_cleanups
);
2361 mi_execute_async_cli_command (char *cli_command
, char **argv
, int argc
)
2363 struct cleanup
*old_cleanups
;
2367 run
= xstrprintf ("%s %s&", cli_command
, argc
? *argv
: "");
2369 run
= xstrprintf ("%s %s", cli_command
, argc
? *argv
: "");
2370 old_cleanups
= make_cleanup (xfree
, run
);
2372 execute_command (run
, 0 /* from_tty */ );
2374 /* Do this before doing any printing. It would appear that some
2375 print code leaves garbage around in the buffer. */
2376 do_cleanups (old_cleanups
);
2380 mi_load_progress (const char *section_name
,
2381 unsigned long sent_so_far
,
2382 unsigned long total_section
,
2383 unsigned long total_sent
,
2384 unsigned long grand_total
)
2386 using namespace std::chrono
;
2387 static steady_clock::time_point last_update
;
2388 static char *previous_sect_name
= NULL
;
2390 struct ui_out
*saved_uiout
;
2391 struct ui_out
*uiout
;
2392 struct mi_interp
*mi
2393 = (struct mi_interp
*) interp_data (current_interpreter ());
2395 /* This function is called through deprecated_show_load_progress
2396 which means uiout may not be correct. Fix it for the duration
2397 of this function. */
2398 saved_uiout
= current_uiout
;
2400 if (current_interp_named_p (INTERP_MI
)
2401 || current_interp_named_p (INTERP_MI2
))
2402 current_uiout
= mi_out_new (2);
2403 else if (current_interp_named_p (INTERP_MI1
))
2404 current_uiout
= mi_out_new (1);
2405 else if (current_interp_named_p (INTERP_MI3
))
2406 current_uiout
= mi_out_new (3);
2410 uiout
= current_uiout
;
2412 new_section
= (previous_sect_name
?
2413 strcmp (previous_sect_name
, section_name
) : 1);
2416 struct cleanup
*cleanup_tuple
;
2418 xfree (previous_sect_name
);
2419 previous_sect_name
= xstrdup (section_name
);
2422 fputs_unfiltered (current_token
, mi
->raw_stdout
);
2423 fputs_unfiltered ("+download", mi
->raw_stdout
);
2424 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2425 ui_out_field_string (uiout
, "section", section_name
);
2426 ui_out_field_int (uiout
, "section-size", total_section
);
2427 ui_out_field_int (uiout
, "total-size", grand_total
);
2428 do_cleanups (cleanup_tuple
);
2429 mi_out_put (uiout
, mi
->raw_stdout
);
2430 fputs_unfiltered ("\n", mi
->raw_stdout
);
2431 gdb_flush (mi
->raw_stdout
);
2434 steady_clock::time_point time_now
= steady_clock::now ();
2435 if (time_now
- last_update
> milliseconds (500))
2437 struct cleanup
*cleanup_tuple
;
2439 last_update
= time_now
;
2441 fputs_unfiltered (current_token
, mi
->raw_stdout
);
2442 fputs_unfiltered ("+download", mi
->raw_stdout
);
2443 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2444 ui_out_field_string (uiout
, "section", section_name
);
2445 ui_out_field_int (uiout
, "section-sent", sent_so_far
);
2446 ui_out_field_int (uiout
, "section-size", total_section
);
2447 ui_out_field_int (uiout
, "total-sent", total_sent
);
2448 ui_out_field_int (uiout
, "total-size", grand_total
);
2449 do_cleanups (cleanup_tuple
);
2450 mi_out_put (uiout
, mi
->raw_stdout
);
2451 fputs_unfiltered ("\n", mi
->raw_stdout
);
2452 gdb_flush (mi
->raw_stdout
);
2456 current_uiout
= saved_uiout
;
2460 timestamp (struct mi_timestamp
*tv
)
2462 using namespace std::chrono
;
2464 tv
->wallclock
= steady_clock::now ();
2465 run_time_clock::now (tv
->utime
, tv
->stime
);
2469 print_diff_now (struct ui_file
*file
, struct mi_timestamp
*start
)
2471 struct mi_timestamp now
;
2474 print_diff (file
, start
, &now
);
2478 mi_print_timing_maybe (struct ui_file
*file
)
2480 /* If the command is -enable-timing then do_timings may be true
2481 whilst current_command_ts is not initialized. */
2482 if (do_timings
&& current_command_ts
)
2483 print_diff_now (file
, current_command_ts
);
2487 print_diff (struct ui_file
*file
, struct mi_timestamp
*start
,
2488 struct mi_timestamp
*end
)
2490 using namespace std::chrono
;
2492 duration
<double> wallclock
= end
->wallclock
- start
->wallclock
;
2493 duration
<double> utime
= end
->utime
- start
->utime
;
2494 duration
<double> stime
= end
->stime
- start
->stime
;
2498 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
2499 wallclock
.count (), utime
.count (), stime
.count ());
2503 mi_cmd_trace_define_variable (char *command
, char **argv
, int argc
)
2505 LONGEST initval
= 0;
2506 struct trace_state_variable
*tsv
;
2509 if (argc
!= 1 && argc
!= 2)
2510 error (_("Usage: -trace-define-variable VARIABLE [VALUE]"));
2514 error (_("Name of trace variable should start with '$'"));
2516 validate_trace_state_variable_name (name
);
2518 tsv
= find_trace_state_variable (name
);
2520 tsv
= create_trace_state_variable (name
);
2523 initval
= value_as_long (parse_and_eval (argv
[1]));
2525 tsv
->initial_value
= initval
;
2529 mi_cmd_trace_list_variables (char *command
, char **argv
, int argc
)
2532 error (_("-trace-list-variables: no arguments allowed"));
2534 tvariables_info_1 ();
2538 mi_cmd_trace_find (char *command
, char **argv
, int argc
)
2543 error (_("trace selection mode is required"));
2547 if (strcmp (mode
, "none") == 0)
2549 tfind_1 (tfind_number
, -1, 0, 0, 0);
2553 check_trace_running (current_trace_status ());
2555 if (strcmp (mode
, "frame-number") == 0)
2558 error (_("frame number is required"));
2559 tfind_1 (tfind_number
, atoi (argv
[1]), 0, 0, 0);
2561 else if (strcmp (mode
, "tracepoint-number") == 0)
2564 error (_("tracepoint number is required"));
2565 tfind_1 (tfind_tp
, atoi (argv
[1]), 0, 0, 0);
2567 else if (strcmp (mode
, "pc") == 0)
2570 error (_("PC is required"));
2571 tfind_1 (tfind_pc
, 0, parse_and_eval_address (argv
[1]), 0, 0);
2573 else if (strcmp (mode
, "pc-inside-range") == 0)
2576 error (_("Start and end PC are required"));
2577 tfind_1 (tfind_range
, 0, parse_and_eval_address (argv
[1]),
2578 parse_and_eval_address (argv
[2]), 0);
2580 else if (strcmp (mode
, "pc-outside-range") == 0)
2583 error (_("Start and end PC are required"));
2584 tfind_1 (tfind_outside
, 0, parse_and_eval_address (argv
[1]),
2585 parse_and_eval_address (argv
[2]), 0);
2587 else if (strcmp (mode
, "line") == 0)
2589 struct symtabs_and_lines sals
;
2590 struct symtab_and_line sal
;
2591 static CORE_ADDR start_pc
, end_pc
;
2592 struct cleanup
*back_to
;
2595 error (_("Line is required"));
2597 sals
= decode_line_with_current_source (argv
[1],
2598 DECODE_LINE_FUNFIRSTLINE
);
2599 back_to
= make_cleanup (xfree
, sals
.sals
);
2603 if (sal
.symtab
== 0)
2604 error (_("Could not find the specified line"));
2606 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2607 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, 0);
2609 error (_("Could not find the specified line"));
2611 do_cleanups (back_to
);
2614 error (_("Invalid mode '%s'"), mode
);
2616 if (has_stack_frames () || get_traceframe_number () >= 0)
2617 print_stack_frame (get_selected_frame (NULL
), 1, LOC_AND_ADDRESS
, 1);
2621 mi_cmd_trace_save (char *command
, char **argv
, int argc
)
2623 int target_saves
= 0;
2624 int generate_ctf
= 0;
2631 TARGET_SAVE_OPT
, CTF_OPT
2633 static const struct mi_opt opts
[] =
2635 {"r", TARGET_SAVE_OPT
, 0},
2636 {"ctf", CTF_OPT
, 0},
2642 int opt
= mi_getopt ("-trace-save", argc
, argv
, opts
,
2647 switch ((enum opt
) opt
)
2649 case TARGET_SAVE_OPT
:
2658 if (argc
- oind
!= 1)
2659 error (_("Exactly one argument required "
2660 "(file in which to save trace data)"));
2662 filename
= argv
[oind
];
2665 trace_save_ctf (filename
, target_saves
);
2667 trace_save_tfile (filename
, target_saves
);
2671 mi_cmd_trace_start (char *command
, char **argv
, int argc
)
2673 start_tracing (NULL
);
2677 mi_cmd_trace_status (char *command
, char **argv
, int argc
)
2679 trace_status_mi (0);
2683 mi_cmd_trace_stop (char *command
, char **argv
, int argc
)
2685 stop_tracing (NULL
);
2686 trace_status_mi (1);
2689 /* Implement the "-ada-task-info" command. */
2692 mi_cmd_ada_task_info (char *command
, char **argv
, int argc
)
2694 if (argc
!= 0 && argc
!= 1)
2695 error (_("Invalid MI command"));
2697 print_ada_task_info (current_uiout
, argv
[0], current_inferior ());
2700 /* Print EXPRESSION according to VALUES. */
2703 print_variable_or_computed (const char *expression
, enum print_values values
)
2705 struct cleanup
*old_chain
;
2707 struct ui_file
*stb
;
2709 struct ui_out
*uiout
= current_uiout
;
2711 stb
= mem_fileopen ();
2712 old_chain
= make_cleanup_ui_file_delete (stb
);
2714 expression_up expr
= parse_expression (expression
);
2716 if (values
== PRINT_SIMPLE_VALUES
)
2717 val
= evaluate_type (expr
.get ());
2719 val
= evaluate_expression (expr
.get ());
2721 if (values
!= PRINT_NO_VALUES
)
2722 make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2723 ui_out_field_string (uiout
, "name", expression
);
2727 case PRINT_SIMPLE_VALUES
:
2728 type
= check_typedef (value_type (val
));
2729 type_print (value_type (val
), "", stb
, -1);
2730 ui_out_field_stream (uiout
, "type", stb
);
2731 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
2732 && TYPE_CODE (type
) != TYPE_CODE_STRUCT
2733 && TYPE_CODE (type
) != TYPE_CODE_UNION
)
2735 struct value_print_options opts
;
2737 get_no_prettyformat_print_options (&opts
);
2739 common_val_print (val
, stb
, 0, &opts
, current_language
);
2740 ui_out_field_stream (uiout
, "value", stb
);
2743 case PRINT_ALL_VALUES
:
2745 struct value_print_options opts
;
2747 get_no_prettyformat_print_options (&opts
);
2749 common_val_print (val
, stb
, 0, &opts
, current_language
);
2750 ui_out_field_stream (uiout
, "value", stb
);
2755 do_cleanups (old_chain
);
2758 /* Implement the "-trace-frame-collected" command. */
2761 mi_cmd_trace_frame_collected (char *command
, char **argv
, int argc
)
2763 struct cleanup
*old_chain
;
2764 struct bp_location
*tloc
;
2766 struct collection_list
*clist
;
2767 struct collection_list tracepoint_list
, stepping_list
;
2768 struct traceframe_info
*tinfo
;
2770 enum print_values var_print_values
= PRINT_ALL_VALUES
;
2771 enum print_values comp_print_values
= PRINT_ALL_VALUES
;
2772 int registers_format
= 'x';
2773 int memory_contents
= 0;
2774 struct ui_out
*uiout
= current_uiout
;
2782 static const struct mi_opt opts
[] =
2784 {"-var-print-values", VAR_PRINT_VALUES
, 1},
2785 {"-comp-print-values", COMP_PRINT_VALUES
, 1},
2786 {"-registers-format", REGISTERS_FORMAT
, 1},
2787 {"-memory-contents", MEMORY_CONTENTS
, 0},
2794 int opt
= mi_getopt ("-trace-frame-collected", argc
, argv
, opts
,
2798 switch ((enum opt
) opt
)
2800 case VAR_PRINT_VALUES
:
2801 var_print_values
= mi_parse_print_values (oarg
);
2803 case COMP_PRINT_VALUES
:
2804 comp_print_values
= mi_parse_print_values (oarg
);
2806 case REGISTERS_FORMAT
:
2807 registers_format
= oarg
[0];
2808 case MEMORY_CONTENTS
:
2809 memory_contents
= 1;
2815 error (_("Usage: -trace-frame-collected "
2816 "[--var-print-values PRINT_VALUES] "
2817 "[--comp-print-values PRINT_VALUES] "
2818 "[--registers-format FORMAT]"
2819 "[--memory-contents]"));
2821 /* This throws an error is not inspecting a trace frame. */
2822 tloc
= get_traceframe_location (&stepping_frame
);
2824 /* This command only makes sense for the current frame, not the
2826 old_chain
= make_cleanup_restore_current_thread ();
2827 select_frame (get_current_frame ());
2829 encode_actions (tloc
, &tracepoint_list
, &stepping_list
);
2832 clist
= &stepping_list
;
2834 clist
= &tracepoint_list
;
2836 tinfo
= get_traceframe_info ();
2838 /* Explicitly wholly collected variables. */
2840 struct cleanup
*list_cleanup
;
2843 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
,
2844 "explicit-variables");
2846 const std::vector
<std::string
> &wholly_collected
2847 = clist
->wholly_collected ();
2848 for (size_t i
= 0; i
< wholly_collected
.size (); i
++)
2850 const std::string
&str
= wholly_collected
[i
];
2851 print_variable_or_computed (str
.c_str (), var_print_values
);
2854 do_cleanups (list_cleanup
);
2857 /* Computed expressions. */
2859 struct cleanup
*list_cleanup
;
2864 = make_cleanup_ui_out_list_begin_end (uiout
,
2865 "computed-expressions");
2867 const std::vector
<std::string
> &computed
= clist
->computed ();
2868 for (size_t i
= 0; i
< computed
.size (); i
++)
2870 const std::string
&str
= computed
[i
];
2871 print_variable_or_computed (str
.c_str (), comp_print_values
);
2874 do_cleanups (list_cleanup
);
2877 /* Registers. Given pseudo-registers, and that some architectures
2878 (like MIPS) actually hide the raw registers, we don't go through
2879 the trace frame info, but instead consult the register cache for
2880 register availability. */
2882 struct cleanup
*list_cleanup
;
2883 struct frame_info
*frame
;
2884 struct gdbarch
*gdbarch
;
2888 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "registers");
2890 frame
= get_selected_frame (NULL
);
2891 gdbarch
= get_frame_arch (frame
);
2892 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
2894 for (regnum
= 0; regnum
< numregs
; regnum
++)
2896 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
2897 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
2900 output_register (frame
, regnum
, registers_format
, 1);
2903 do_cleanups (list_cleanup
);
2906 /* Trace state variables. */
2908 struct cleanup
*list_cleanup
;
2913 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "tvars");
2916 make_cleanup (free_current_contents
, &tsvname
);
2918 for (i
= 0; VEC_iterate (int, tinfo
->tvars
, i
, tvar
); i
++)
2920 struct cleanup
*cleanup_child
;
2921 struct trace_state_variable
*tsv
;
2923 tsv
= find_trace_state_variable_by_number (tvar
);
2925 cleanup_child
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2929 tsvname
= (char *) xrealloc (tsvname
, strlen (tsv
->name
) + 2);
2931 strcpy (tsvname
+ 1, tsv
->name
);
2932 ui_out_field_string (uiout
, "name", tsvname
);
2934 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
2936 ui_out_field_int (uiout
, "current", tsv
->value
);
2940 ui_out_field_skip (uiout
, "name");
2941 ui_out_field_skip (uiout
, "current");
2944 do_cleanups (cleanup_child
);
2947 do_cleanups (list_cleanup
);
2952 struct cleanup
*list_cleanup
;
2953 VEC(mem_range_s
) *available_memory
= NULL
;
2954 struct mem_range
*r
;
2957 traceframe_available_memory (&available_memory
, 0, ULONGEST_MAX
);
2958 make_cleanup (VEC_cleanup(mem_range_s
), &available_memory
);
2960 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "memory");
2962 for (i
= 0; VEC_iterate (mem_range_s
, available_memory
, i
, r
); i
++)
2964 struct cleanup
*cleanup_child
;
2966 struct gdbarch
*gdbarch
= target_gdbarch ();
2968 cleanup_child
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2970 ui_out_field_core_addr (uiout
, "address", gdbarch
, r
->start
);
2971 ui_out_field_int (uiout
, "length", r
->length
);
2973 data
= (gdb_byte
*) xmalloc (r
->length
);
2974 make_cleanup (xfree
, data
);
2976 if (memory_contents
)
2978 if (target_read_memory (r
->start
, data
, r
->length
) == 0)
2983 data_str
= (char *) xmalloc (r
->length
* 2 + 1);
2984 make_cleanup (xfree
, data_str
);
2986 for (m
= 0, p
= data_str
; m
< r
->length
; ++m
, p
+= 2)
2987 sprintf (p
, "%02x", data
[m
]);
2988 ui_out_field_string (uiout
, "contents", data_str
);
2991 ui_out_field_skip (uiout
, "contents");
2993 do_cleanups (cleanup_child
);
2996 do_cleanups (list_cleanup
);
2999 do_cleanups (old_chain
);
3003 _initialize_mi_main (void)
3005 struct cmd_list_element
*c
;
3007 add_setshow_boolean_cmd ("mi-async", class_run
,
3009 Set whether MI asynchronous mode is enabled."), _("\
3010 Show whether MI asynchronous mode is enabled."), _("\
3011 Tells GDB whether MI should be in asynchronous mode."),
3012 set_mi_async_command
,
3013 show_mi_async_command
,
3017 /* Alias old "target-async" to "mi-async". */
3018 c
= add_alias_cmd ("target-async", "mi-async", class_run
, 0, &setlist
);
3019 deprecate_cmd (c
, "set mi-async");
3020 c
= add_alias_cmd ("target-async", "mi-async", class_run
, 0, &showlist
);
3021 deprecate_cmd (c
, "show mi-async");