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 "gdb_sys_time.h"
61 #if defined HAVE_SYS_RESOURCE_H
62 #include <sys/resource.h>
76 /* This is used to pass the current command timestamp down to
77 continuation routines. */
78 static struct mi_timestamp
*current_command_ts
;
80 static int do_timings
= 0;
83 /* Few commands would like to know if options like --thread-group were
84 explicitly specified. This variable keeps the current parsed
85 command including all option, and make it possible. */
86 static struct mi_parse
*current_context
;
88 int running_result_record_printed
= 1;
90 /* Flag indicating that the target has proceeded since the last
91 command was issued. */
94 extern void _initialize_mi_main (void);
95 static void mi_cmd_execute (struct mi_parse
*parse
);
97 static void mi_execute_cli_command (const char *cmd
, int args_p
,
99 static void mi_execute_async_cli_command (char *cli_command
,
100 char **argv
, int argc
);
101 static int register_changed_p (int regnum
, struct regcache
*,
103 static void output_register (struct frame_info
*, int regnum
, int format
,
104 int skip_unavailable
);
106 /* Controls whether the frontend wants MI in async mode. */
107 static int mi_async
= 0;
109 /* The set command writes to this variable. If the inferior is
110 executing, mi_async is *not* updated. */
111 static int mi_async_1
= 0;
114 set_mi_async_command (char *args
, int from_tty
,
115 struct cmd_list_element
*c
)
117 if (have_live_inferiors ())
119 mi_async_1
= mi_async
;
120 error (_("Cannot change this setting while the inferior is running."));
123 mi_async
= mi_async_1
;
127 show_mi_async_command (struct ui_file
*file
, int from_tty
,
128 struct cmd_list_element
*c
,
131 fprintf_filtered (file
,
132 _("Whether MI is in asynchronous mode is %s.\n"),
136 /* A wrapper for target_can_async_p that takes the MI setting into
142 return mi_async
&& target_can_async_p ();
145 /* Command implementations. FIXME: Is this libgdb? No. This is the MI
146 layer that calls libgdb. Any operation used in the below should be
149 static void timestamp (struct mi_timestamp
*tv
);
151 static void print_diff (struct ui_file
*file
, struct mi_timestamp
*start
,
152 struct mi_timestamp
*end
);
155 mi_cmd_gdb_exit (char *command
, char **argv
, int argc
)
158 = (struct mi_interp
*) interp_data (current_interpreter ());
160 /* We have to print everything right here because we never return. */
162 fputs_unfiltered (current_token
, mi
->raw_stdout
);
163 fputs_unfiltered ("^exit\n", mi
->raw_stdout
);
164 mi_out_put (current_uiout
, mi
->raw_stdout
);
165 gdb_flush (mi
->raw_stdout
);
166 /* FIXME: The function called is not yet a formal libgdb function. */
167 quit_force (NULL
, FROM_TTY
);
171 mi_cmd_exec_next (char *command
, char **argv
, int argc
)
173 /* FIXME: Should call a libgdb function, not a cli wrapper. */
174 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
175 mi_execute_async_cli_command ("reverse-next", argv
+ 1, argc
- 1);
177 mi_execute_async_cli_command ("next", argv
, argc
);
181 mi_cmd_exec_next_instruction (char *command
, char **argv
, int argc
)
183 /* FIXME: Should call a libgdb function, not a cli wrapper. */
184 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
185 mi_execute_async_cli_command ("reverse-nexti", argv
+ 1, argc
- 1);
187 mi_execute_async_cli_command ("nexti", argv
, argc
);
191 mi_cmd_exec_step (char *command
, char **argv
, int argc
)
193 /* FIXME: Should call a libgdb function, not a cli wrapper. */
194 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
195 mi_execute_async_cli_command ("reverse-step", argv
+ 1, argc
- 1);
197 mi_execute_async_cli_command ("step", argv
, argc
);
201 mi_cmd_exec_step_instruction (char *command
, char **argv
, int argc
)
203 /* FIXME: Should call a libgdb function, not a cli wrapper. */
204 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
205 mi_execute_async_cli_command ("reverse-stepi", argv
+ 1, argc
- 1);
207 mi_execute_async_cli_command ("stepi", argv
, argc
);
211 mi_cmd_exec_finish (char *command
, char **argv
, int argc
)
213 /* FIXME: Should call a libgdb function, not a cli wrapper. */
214 if (argc
> 0 && strcmp(argv
[0], "--reverse") == 0)
215 mi_execute_async_cli_command ("reverse-finish", argv
+ 1, argc
- 1);
217 mi_execute_async_cli_command ("finish", argv
, argc
);
221 mi_cmd_exec_return (char *command
, char **argv
, int argc
)
223 /* This command doesn't really execute the target, it just pops the
224 specified number of frames. */
226 /* Call return_command with from_tty argument equal to 0 so as to
227 avoid being queried. */
228 return_command (*argv
, 0);
230 /* Call return_command with from_tty argument equal to 0 so as to
231 avoid being queried. */
232 return_command (NULL
, 0);
234 /* Because we have called return_command with from_tty = 0, we need
235 to print the frame here. */
236 print_stack_frame (get_selected_frame (NULL
), 1, LOC_AND_ADDRESS
, 1);
240 mi_cmd_exec_jump (char *args
, char **argv
, int argc
)
242 /* FIXME: Should call a libgdb function, not a cli wrapper. */
243 mi_execute_async_cli_command ("jump", argv
, argc
);
247 proceed_thread (struct thread_info
*thread
, int pid
)
249 if (!is_stopped (thread
->ptid
))
252 if (pid
!= 0 && ptid_get_pid (thread
->ptid
) != pid
)
255 switch_to_thread (thread
->ptid
);
256 clear_proceed_status (0);
257 proceed ((CORE_ADDR
) -1, GDB_SIGNAL_DEFAULT
);
261 proceed_thread_callback (struct thread_info
*thread
, void *arg
)
263 int pid
= *(int *)arg
;
265 proceed_thread (thread
, pid
);
270 exec_continue (char **argv
, int argc
)
272 prepare_execution_command (¤t_target
, mi_async_p ());
276 /* In non-stop mode, 'resume' always resumes a single thread.
277 Therefore, to resume all threads of the current inferior, or
278 all threads in all inferiors, we need to iterate over
281 See comment on infcmd.c:proceed_thread_callback for rationale. */
282 if (current_context
->all
|| current_context
->thread_group
!= -1)
285 struct cleanup
*back_to
= make_cleanup_restore_current_thread ();
287 if (!current_context
->all
)
290 = find_inferior_id (current_context
->thread_group
);
294 iterate_over_threads (proceed_thread_callback
, &pid
);
295 do_cleanups (back_to
);
304 scoped_restore save_multi
= make_scoped_restore (&sched_multi
);
306 if (current_context
->all
)
313 /* In all-stop mode, -exec-continue traditionally resumed
314 either all threads, or one thread, depending on the
315 'scheduler-locking' variable. Let's continue to do the
323 exec_direction_forward (void *notused
)
325 execution_direction
= EXEC_FORWARD
;
329 exec_reverse_continue (char **argv
, int argc
)
331 enum exec_direction_kind dir
= execution_direction
;
332 struct cleanup
*old_chain
;
334 if (dir
== EXEC_REVERSE
)
335 error (_("Already in reverse mode."));
337 if (!target_can_execute_reverse
)
338 error (_("Target %s does not support this command."), target_shortname
);
340 old_chain
= make_cleanup (exec_direction_forward
, NULL
);
341 execution_direction
= EXEC_REVERSE
;
342 exec_continue (argv
, argc
);
343 do_cleanups (old_chain
);
347 mi_cmd_exec_continue (char *command
, char **argv
, int argc
)
349 if (argc
> 0 && strcmp (argv
[0], "--reverse") == 0)
350 exec_reverse_continue (argv
+ 1, argc
- 1);
352 exec_continue (argv
, argc
);
356 interrupt_thread_callback (struct thread_info
*thread
, void *arg
)
358 int pid
= *(int *)arg
;
360 if (!is_running (thread
->ptid
))
363 if (ptid_get_pid (thread
->ptid
) != pid
)
366 target_stop (thread
->ptid
);
370 /* Interrupt the execution of the target. Note how we must play
371 around with the token variables, in order to display the current
372 token in the result of the interrupt command, and the previous
373 execution token when the target finally stops. See comments in
377 mi_cmd_exec_interrupt (char *command
, char **argv
, int argc
)
379 /* In all-stop mode, everything stops, so we don't need to try
380 anything specific. */
383 interrupt_target_1 (0);
387 if (current_context
->all
)
389 /* This will interrupt all threads in all inferiors. */
390 interrupt_target_1 (1);
392 else if (current_context
->thread_group
!= -1)
394 struct inferior
*inf
= find_inferior_id (current_context
->thread_group
);
396 iterate_over_threads (interrupt_thread_callback
, &inf
->pid
);
400 /* Interrupt just the current thread -- either explicitly
401 specified via --thread or whatever was current before
402 MI command was sent. */
403 interrupt_target_1 (0);
407 /* Callback for iterate_over_inferiors which starts the execution
408 of the given inferior.
410 ARG is a pointer to an integer whose value, if non-zero, indicates
411 that the program should be stopped when reaching the main subprogram
412 (similar to what the CLI "start" command does). */
415 run_one_inferior (struct inferior
*inf
, void *arg
)
417 int start_p
= *(int *) arg
;
418 const char *run_cmd
= start_p
? "start" : "run";
419 struct target_ops
*run_target
= find_run_target ();
420 int async_p
= mi_async
&& run_target
->to_can_async_p (run_target
);
424 if (inf
->pid
!= ptid_get_pid (inferior_ptid
))
426 struct thread_info
*tp
;
428 tp
= any_thread_of_process (inf
->pid
);
430 error (_("Inferior has no threads."));
432 switch_to_thread (tp
->ptid
);
437 set_current_inferior (inf
);
438 switch_to_thread (null_ptid
);
439 set_current_program_space (inf
->pspace
);
441 mi_execute_cli_command (run_cmd
, async_p
,
442 async_p
? "&" : NULL
);
447 mi_cmd_exec_run (char *command
, char **argv
, int argc
)
451 /* Parse the command options. */
456 static const struct mi_opt opts
[] =
458 {"-start", START_OPT
, 0},
467 int opt
= mi_getopt ("-exec-run", argc
, argv
, opts
, &oind
, &oarg
);
471 switch ((enum opt
) opt
)
479 /* This command does not accept any argument. Make sure the user
480 did not provide any. */
482 error (_("Invalid argument: %s"), argv
[oind
]);
484 if (current_context
->all
)
486 struct cleanup
*back_to
= save_current_space_and_thread ();
488 iterate_over_inferiors (run_one_inferior
, &start_p
);
489 do_cleanups (back_to
);
493 const char *run_cmd
= start_p
? "start" : "run";
494 struct target_ops
*run_target
= find_run_target ();
495 int async_p
= mi_async
&& run_target
->to_can_async_p (run_target
);
497 mi_execute_cli_command (run_cmd
, async_p
,
498 async_p
? "&" : NULL
);
504 find_thread_of_process (struct thread_info
*ti
, void *p
)
508 if (ptid_get_pid (ti
->ptid
) == pid
&& !is_exited (ti
->ptid
))
515 mi_cmd_target_detach (char *command
, char **argv
, int argc
)
517 if (argc
!= 0 && argc
!= 1)
518 error (_("Usage: -target-detach [pid | thread-group]"));
522 struct thread_info
*tp
;
526 /* First see if we are dealing with a thread-group id. */
529 struct inferior
*inf
;
530 int id
= strtoul (argv
[0] + 1, &end
, 0);
533 error (_("Invalid syntax of thread-group id '%s'"), argv
[0]);
535 inf
= find_inferior_id (id
);
537 error (_("Non-existent thread-group id '%d'"), id
);
543 /* We must be dealing with a pid. */
544 pid
= strtol (argv
[0], &end
, 10);
547 error (_("Invalid identifier '%s'"), argv
[0]);
550 /* Pick any thread in the desired process. Current
551 target_detach detaches from the parent of inferior_ptid. */
552 tp
= iterate_over_threads (find_thread_of_process
, &pid
);
554 error (_("Thread group is empty"));
556 switch_to_thread (tp
->ptid
);
559 detach_command (NULL
, 0);
563 mi_cmd_thread_select (char *command
, char **argv
, int argc
)
566 char *mi_error_message
;
567 ptid_t previous_ptid
= inferior_ptid
;
570 error (_("-thread-select: USAGE: threadnum."));
572 rc
= gdb_thread_select (current_uiout
, argv
[0], &mi_error_message
);
574 /* If thread switch did not succeed don't notify or print. */
575 if (rc
== GDB_RC_FAIL
)
577 make_cleanup (xfree
, mi_error_message
);
578 error ("%s", mi_error_message
);
581 print_selected_thread_frame (current_uiout
,
582 USER_SELECTED_THREAD
| USER_SELECTED_FRAME
);
584 /* Notify if the thread has effectively changed. */
585 if (!ptid_equal (inferior_ptid
, previous_ptid
))
587 observer_notify_user_selected_context_changed (USER_SELECTED_THREAD
588 | USER_SELECTED_FRAME
);
593 mi_cmd_thread_list_ids (char *command
, char **argv
, int argc
)
596 char *mi_error_message
;
599 error (_("-thread-list-ids: No arguments required."));
601 rc
= gdb_list_thread_ids (current_uiout
, &mi_error_message
);
603 if (rc
== GDB_RC_FAIL
)
605 make_cleanup (xfree
, mi_error_message
);
606 error ("%s", mi_error_message
);
611 mi_cmd_thread_info (char *command
, char **argv
, int argc
)
613 if (argc
!= 0 && argc
!= 1)
614 error (_("Invalid MI command"));
616 print_thread_info (current_uiout
, argv
[0], -1);
619 struct collect_cores_data
627 collect_cores (struct thread_info
*ti
, void *xdata
)
629 struct collect_cores_data
*data
= (struct collect_cores_data
*) xdata
;
631 if (ptid_get_pid (ti
->ptid
) == data
->pid
)
633 int core
= target_core_of_thread (ti
->ptid
);
636 VEC_safe_push (int, data
->cores
, core
);
643 unique (int *b
, int *e
)
653 struct print_one_inferior_data
656 VEC (int) *inferiors
;
660 print_one_inferior (struct inferior
*inferior
, void *xdata
)
662 struct print_one_inferior_data
*top_data
663 = (struct print_one_inferior_data
*) xdata
;
664 struct ui_out
*uiout
= current_uiout
;
666 if (VEC_empty (int, top_data
->inferiors
)
667 || bsearch (&(inferior
->pid
), VEC_address (int, top_data
->inferiors
),
668 VEC_length (int, top_data
->inferiors
), sizeof (int),
669 compare_positive_ints
))
671 struct collect_cores_data data
;
672 struct cleanup
*back_to
673 = make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
675 ui_out_field_fmt (uiout
, "id", "i%d", inferior
->num
);
676 ui_out_field_string (uiout
, "type", "process");
677 if (inferior
->has_exit_code
)
678 ui_out_field_string (uiout
, "exit-code",
679 int_string (inferior
->exit_code
, 8, 0, 0, 1));
680 if (inferior
->pid
!= 0)
681 ui_out_field_int (uiout
, "pid", inferior
->pid
);
683 if (inferior
->pspace
->pspace_exec_filename
!= NULL
)
685 ui_out_field_string (uiout
, "executable",
686 inferior
->pspace
->pspace_exec_filename
);
690 if (inferior
->pid
!= 0)
692 data
.pid
= inferior
->pid
;
693 iterate_over_threads (collect_cores
, &data
);
696 if (!VEC_empty (int, data
.cores
))
699 struct cleanup
*back_to_2
=
700 make_cleanup_ui_out_list_begin_end (uiout
, "cores");
702 qsort (VEC_address (int, data
.cores
),
703 VEC_length (int, data
.cores
), sizeof (int),
704 compare_positive_ints
);
706 b
= VEC_address (int, data
.cores
);
707 e
= b
+ VEC_length (int, data
.cores
);
711 ui_out_field_int (uiout
, NULL
, *b
);
713 do_cleanups (back_to_2
);
716 if (top_data
->recurse
)
717 print_thread_info (uiout
, NULL
, inferior
->pid
);
719 do_cleanups (back_to
);
725 /* Output a field named 'cores' with a list as the value. The
726 elements of the list are obtained by splitting 'cores' on
730 output_cores (struct ui_out
*uiout
, const char *field_name
, const char *xcores
)
732 struct cleanup
*back_to
= make_cleanup_ui_out_list_begin_end (uiout
,
734 char *cores
= xstrdup (xcores
);
737 make_cleanup (xfree
, cores
);
739 for (p
= strtok (p
, ","); p
; p
= strtok (NULL
, ","))
740 ui_out_field_string (uiout
, NULL
, p
);
742 do_cleanups (back_to
);
746 free_vector_of_ints (void *xvector
)
748 VEC (int) **vector
= (VEC (int) **) xvector
;
750 VEC_free (int, *vector
);
754 do_nothing (splay_tree_key k
)
759 free_vector_of_osdata_items (splay_tree_value xvalue
)
761 VEC (osdata_item_s
) *value
= (VEC (osdata_item_s
) *) xvalue
;
763 /* We don't free the items itself, it will be done separately. */
764 VEC_free (osdata_item_s
, value
);
768 splay_tree_int_comparator (splay_tree_key xa
, splay_tree_key xb
)
777 free_splay_tree (void *xt
)
779 splay_tree t
= (splay_tree
) xt
;
780 splay_tree_delete (t
);
784 list_available_thread_groups (VEC (int) *ids
, int recurse
)
787 struct osdata_item
*item
;
789 struct ui_out
*uiout
= current_uiout
;
790 struct cleanup
*cleanup
;
792 /* This keeps a map from integer (pid) to VEC (struct osdata_item *)*
793 The vector contains information about all threads for the given pid.
794 This is assigned an initial value to avoid "may be used uninitialized"
796 splay_tree tree
= NULL
;
798 /* get_osdata will throw if it cannot return data. */
799 data
= get_osdata ("processes");
800 cleanup
= make_cleanup_osdata_free (data
);
804 struct osdata
*threads
= get_osdata ("threads");
806 make_cleanup_osdata_free (threads
);
807 tree
= splay_tree_new (splay_tree_int_comparator
,
809 free_vector_of_osdata_items
);
810 make_cleanup (free_splay_tree
, tree
);
813 VEC_iterate (osdata_item_s
, threads
->items
,
817 const char *pid
= get_osdata_column (item
, "pid");
818 int pid_i
= strtoul (pid
, NULL
, 0);
819 VEC (osdata_item_s
) *vec
= 0;
821 splay_tree_node n
= splay_tree_lookup (tree
, pid_i
);
824 VEC_safe_push (osdata_item_s
, vec
, item
);
825 splay_tree_insert (tree
, pid_i
, (splay_tree_value
)vec
);
829 vec
= (VEC (osdata_item_s
) *) n
->value
;
830 VEC_safe_push (osdata_item_s
, vec
, item
);
831 n
->value
= (splay_tree_value
) vec
;
836 make_cleanup_ui_out_list_begin_end (uiout
, "groups");
839 VEC_iterate (osdata_item_s
, data
->items
,
843 struct cleanup
*back_to
;
845 const char *pid
= get_osdata_column (item
, "pid");
846 const char *cmd
= get_osdata_column (item
, "command");
847 const char *user
= get_osdata_column (item
, "user");
848 const char *cores
= get_osdata_column (item
, "cores");
850 int pid_i
= strtoul (pid
, NULL
, 0);
852 /* At present, the target will return all available processes
853 and if information about specific ones was required, we filter
854 undesired processes here. */
855 if (ids
&& bsearch (&pid_i
, VEC_address (int, ids
),
856 VEC_length (int, ids
),
857 sizeof (int), compare_positive_ints
) == NULL
)
861 back_to
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
863 ui_out_field_fmt (uiout
, "id", "%s", pid
);
864 ui_out_field_string (uiout
, "type", "process");
866 ui_out_field_string (uiout
, "description", cmd
);
868 ui_out_field_string (uiout
, "user", user
);
870 output_cores (uiout
, "cores", cores
);
874 splay_tree_node n
= splay_tree_lookup (tree
, pid_i
);
877 VEC (osdata_item_s
) *children
= (VEC (osdata_item_s
) *) n
->value
;
878 struct osdata_item
*child
;
881 make_cleanup_ui_out_list_begin_end (uiout
, "threads");
884 VEC_iterate (osdata_item_s
, children
, ix_child
, child
);
887 struct cleanup
*back_to_2
=
888 make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
889 const char *tid
= get_osdata_column (child
, "tid");
890 const char *tcore
= get_osdata_column (child
, "core");
892 ui_out_field_string (uiout
, "id", tid
);
894 ui_out_field_string (uiout
, "core", tcore
);
896 do_cleanups (back_to_2
);
901 do_cleanups (back_to
);
904 do_cleanups (cleanup
);
908 mi_cmd_list_thread_groups (char *command
, char **argv
, int argc
)
910 struct ui_out
*uiout
= current_uiout
;
911 struct cleanup
*back_to
;
918 AVAILABLE_OPT
, RECURSE_OPT
920 static const struct mi_opt opts
[] =
922 {"-available", AVAILABLE_OPT
, 0},
923 {"-recurse", RECURSE_OPT
, 1},
932 int opt
= mi_getopt ("-list-thread-groups", argc
, argv
, opts
,
937 switch ((enum opt
) opt
)
943 if (strcmp (oarg
, "0") == 0)
945 else if (strcmp (oarg
, "1") == 0)
948 error (_("only '0' and '1' are valid values "
949 "for the '--recurse' option"));
954 for (; oind
< argc
; ++oind
)
959 if (*(argv
[oind
]) != 'i')
960 error (_("invalid syntax of group id '%s'"), argv
[oind
]);
962 inf
= strtoul (argv
[oind
] + 1, &end
, 0);
965 error (_("invalid syntax of group id '%s'"), argv
[oind
]);
966 VEC_safe_push (int, ids
, inf
);
968 if (VEC_length (int, ids
) > 1)
969 qsort (VEC_address (int, ids
),
970 VEC_length (int, ids
),
971 sizeof (int), compare_positive_ints
);
973 back_to
= make_cleanup (free_vector_of_ints
, &ids
);
977 list_available_thread_groups (ids
, recurse
);
979 else if (VEC_length (int, ids
) == 1)
981 /* Local thread groups, single id. */
982 int id
= *VEC_address (int, ids
);
983 struct inferior
*inf
= find_inferior_id (id
);
986 error (_("Non-existent thread group id '%d'"), id
);
988 print_thread_info (uiout
, NULL
, inf
->pid
);
992 struct print_one_inferior_data data
;
994 data
.recurse
= recurse
;
995 data
.inferiors
= ids
;
997 /* Local thread groups. Either no explicit ids -- and we
998 print everything, or several explicit ids. In both cases,
999 we print more than one group, and have to use 'groups'
1000 as the top-level element. */
1001 make_cleanup_ui_out_list_begin_end (uiout
, "groups");
1002 update_thread_list ();
1003 iterate_over_inferiors (print_one_inferior
, &data
);
1006 do_cleanups (back_to
);
1010 mi_cmd_data_list_register_names (char *command
, char **argv
, int argc
)
1012 struct gdbarch
*gdbarch
;
1013 struct ui_out
*uiout
= current_uiout
;
1014 int regnum
, numregs
;
1016 struct cleanup
*cleanup
;
1018 /* Note that the test for a valid register must include checking the
1019 gdbarch_register_name because gdbarch_num_regs may be allocated
1020 for the union of the register sets within a family of related
1021 processors. In this case, some entries of gdbarch_register_name
1022 will change depending upon the particular processor being
1025 gdbarch
= get_current_arch ();
1026 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1028 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "register-names");
1030 if (argc
== 0) /* No args, just do all the regs. */
1036 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1037 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1038 ui_out_field_string (uiout
, NULL
, "");
1040 ui_out_field_string (uiout
, NULL
,
1041 gdbarch_register_name (gdbarch
, regnum
));
1045 /* Else, list of register #s, just do listed regs. */
1046 for (i
= 0; i
< argc
; i
++)
1048 regnum
= atoi (argv
[i
]);
1049 if (regnum
< 0 || regnum
>= numregs
)
1050 error (_("bad register number"));
1052 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1053 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1054 ui_out_field_string (uiout
, NULL
, "");
1056 ui_out_field_string (uiout
, NULL
,
1057 gdbarch_register_name (gdbarch
, regnum
));
1059 do_cleanups (cleanup
);
1063 mi_cmd_data_list_changed_registers (char *command
, char **argv
, int argc
)
1065 static struct regcache
*this_regs
= NULL
;
1066 struct ui_out
*uiout
= current_uiout
;
1067 struct regcache
*prev_regs
;
1068 struct gdbarch
*gdbarch
;
1069 int regnum
, numregs
, changed
;
1071 struct cleanup
*cleanup
;
1073 /* The last time we visited this function, the current frame's
1074 register contents were saved in THIS_REGS. Move THIS_REGS over
1075 to PREV_REGS, and refresh THIS_REGS with the now-current register
1078 prev_regs
= this_regs
;
1079 this_regs
= frame_save_as_regcache (get_selected_frame (NULL
));
1080 cleanup
= make_cleanup_regcache_xfree (prev_regs
);
1082 /* Note that the test for a valid register must include checking the
1083 gdbarch_register_name because gdbarch_num_regs may be allocated
1084 for the union of the register sets within a family of related
1085 processors. In this case, some entries of gdbarch_register_name
1086 will change depending upon the particular processor being
1089 gdbarch
= get_regcache_arch (this_regs
);
1090 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1092 make_cleanup_ui_out_list_begin_end (uiout
, "changed-registers");
1096 /* No args, just do all the regs. */
1101 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1102 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1104 changed
= register_changed_p (regnum
, prev_regs
, this_regs
);
1106 error (_("-data-list-changed-registers: "
1107 "Unable to read register contents."));
1109 ui_out_field_int (uiout
, NULL
, regnum
);
1113 /* Else, list of register #s, just do listed regs. */
1114 for (i
= 0; i
< argc
; i
++)
1116 regnum
= atoi (argv
[i
]);
1120 && gdbarch_register_name (gdbarch
, regnum
) != NULL
1121 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
1123 changed
= register_changed_p (regnum
, prev_regs
, this_regs
);
1125 error (_("-data-list-changed-registers: "
1126 "Unable to read register contents."));
1128 ui_out_field_int (uiout
, NULL
, regnum
);
1131 error (_("bad register number"));
1133 do_cleanups (cleanup
);
1137 register_changed_p (int regnum
, struct regcache
*prev_regs
,
1138 struct regcache
*this_regs
)
1140 struct gdbarch
*gdbarch
= get_regcache_arch (this_regs
);
1141 gdb_byte prev_buffer
[MAX_REGISTER_SIZE
];
1142 gdb_byte this_buffer
[MAX_REGISTER_SIZE
];
1143 enum register_status prev_status
;
1144 enum register_status this_status
;
1146 /* First time through or after gdbarch change consider all registers
1148 if (!prev_regs
|| get_regcache_arch (prev_regs
) != gdbarch
)
1151 /* Get register contents and compare. */
1152 prev_status
= regcache_cooked_read (prev_regs
, regnum
, prev_buffer
);
1153 this_status
= regcache_cooked_read (this_regs
, regnum
, this_buffer
);
1155 if (this_status
!= prev_status
)
1157 else if (this_status
== REG_VALID
)
1158 return memcmp (prev_buffer
, this_buffer
,
1159 register_size (gdbarch
, regnum
)) != 0;
1164 /* Return a list of register number and value pairs. The valid
1165 arguments expected are: a letter indicating the format in which to
1166 display the registers contents. This can be one of: x
1167 (hexadecimal), d (decimal), N (natural), t (binary), o (octal), r
1168 (raw). After the format argument there can be a sequence of
1169 numbers, indicating which registers to fetch the content of. If
1170 the format is the only argument, a list of all the registers with
1171 their values is returned. */
1174 mi_cmd_data_list_register_values (char *command
, char **argv
, int argc
)
1176 struct ui_out
*uiout
= current_uiout
;
1177 struct frame_info
*frame
;
1178 struct gdbarch
*gdbarch
;
1179 int regnum
, numregs
, format
;
1181 struct cleanup
*list_cleanup
;
1182 int skip_unavailable
= 0;
1188 static const struct mi_opt opts
[] =
1190 {"-skip-unavailable", SKIP_UNAVAILABLE
, 0},
1194 /* Note that the test for a valid register must include checking the
1195 gdbarch_register_name because gdbarch_num_regs may be allocated
1196 for the union of the register sets within a family of related
1197 processors. In this case, some entries of gdbarch_register_name
1198 will change depending upon the particular processor being
1204 int opt
= mi_getopt ("-data-list-register-values", argc
, argv
,
1205 opts
, &oind
, &oarg
);
1209 switch ((enum opt
) opt
)
1211 case SKIP_UNAVAILABLE
:
1212 skip_unavailable
= 1;
1217 if (argc
- oind
< 1)
1218 error (_("-data-list-register-values: Usage: "
1219 "-data-list-register-values [--skip-unavailable] <format>"
1220 " [<regnum1>...<regnumN>]"));
1222 format
= (int) argv
[oind
][0];
1224 frame
= get_selected_frame (NULL
);
1225 gdbarch
= get_frame_arch (frame
);
1226 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1228 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "register-values");
1230 if (argc
- oind
== 1)
1232 /* No args, beside the format: do all the regs. */
1237 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
1238 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
1241 output_register (frame
, regnum
, format
, skip_unavailable
);
1245 /* Else, list of register #s, just do listed regs. */
1246 for (i
= 1 + oind
; i
< argc
; i
++)
1248 regnum
= atoi (argv
[i
]);
1252 && gdbarch_register_name (gdbarch
, regnum
) != NULL
1253 && *gdbarch_register_name (gdbarch
, regnum
) != '\000')
1254 output_register (frame
, regnum
, format
, skip_unavailable
);
1256 error (_("bad register number"));
1258 do_cleanups (list_cleanup
);
1261 /* Output one register REGNUM's contents in the desired FORMAT. If
1262 SKIP_UNAVAILABLE is true, skip the register if it is
1266 output_register (struct frame_info
*frame
, int regnum
, int format
,
1267 int skip_unavailable
)
1269 struct ui_out
*uiout
= current_uiout
;
1270 struct value
*val
= value_of_register (regnum
, frame
);
1271 struct cleanup
*tuple_cleanup
;
1272 struct value_print_options opts
;
1273 struct ui_file
*stb
;
1275 if (skip_unavailable
&& !value_entirely_available (val
))
1278 tuple_cleanup
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1279 ui_out_field_int (uiout
, "number", regnum
);
1287 stb
= mem_fileopen ();
1288 make_cleanup_ui_file_delete (stb
);
1290 get_formatted_print_options (&opts
, format
);
1292 val_print (value_type (val
),
1293 value_contents_for_printing (val
),
1294 value_embedded_offset (val
), 0,
1295 stb
, 0, val
, &opts
, current_language
);
1296 ui_out_field_stream (uiout
, "value", stb
);
1298 do_cleanups (tuple_cleanup
);
1301 /* Write given values into registers. The registers and values are
1302 given as pairs. The corresponding MI command is
1303 -data-write-register-values <format>
1304 [<regnum1> <value1>...<regnumN> <valueN>] */
1306 mi_cmd_data_write_register_values (char *command
, char **argv
, int argc
)
1308 struct regcache
*regcache
;
1309 struct gdbarch
*gdbarch
;
1312 /* Note that the test for a valid register must include checking the
1313 gdbarch_register_name because gdbarch_num_regs may be allocated
1314 for the union of the register sets within a family of related
1315 processors. In this case, some entries of gdbarch_register_name
1316 will change depending upon the particular processor being
1319 regcache
= get_current_regcache ();
1320 gdbarch
= get_regcache_arch (regcache
);
1321 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
1324 error (_("-data-write-register-values: Usage: -data-write-register-"
1325 "values <format> [<regnum1> <value1>...<regnumN> <valueN>]"));
1327 if (!target_has_registers
)
1328 error (_("-data-write-register-values: No registers."));
1331 error (_("-data-write-register-values: No regs and values specified."));
1334 error (_("-data-write-register-values: "
1335 "Regs and vals are not in pairs."));
1337 for (i
= 1; i
< argc
; i
= i
+ 2)
1339 int regnum
= atoi (argv
[i
]);
1341 if (regnum
>= 0 && regnum
< numregs
1342 && gdbarch_register_name (gdbarch
, regnum
)
1343 && *gdbarch_register_name (gdbarch
, regnum
))
1347 /* Get the value as a number. */
1348 value
= parse_and_eval_address (argv
[i
+ 1]);
1350 /* Write it down. */
1351 regcache_cooked_write_signed (regcache
, regnum
, value
);
1354 error (_("bad register number"));
1358 /* Evaluate the value of the argument. The argument is an
1359 expression. If the expression contains spaces it needs to be
1360 included in double quotes. */
1363 mi_cmd_data_evaluate_expression (char *command
, char **argv
, int argc
)
1365 struct expression
*expr
;
1366 struct cleanup
*old_chain
;
1368 struct ui_file
*stb
;
1369 struct value_print_options opts
;
1370 struct ui_out
*uiout
= current_uiout
;
1372 stb
= mem_fileopen ();
1373 old_chain
= make_cleanup_ui_file_delete (stb
);
1376 error (_("-data-evaluate-expression: "
1377 "Usage: -data-evaluate-expression expression"));
1379 expr
= parse_expression (argv
[0]);
1381 make_cleanup (free_current_contents
, &expr
);
1383 val
= evaluate_expression (expr
);
1385 /* Print the result of the expression evaluation. */
1386 get_user_print_options (&opts
);
1388 common_val_print (val
, stb
, 0, &opts
, current_language
);
1390 ui_out_field_stream (uiout
, "value", stb
);
1392 do_cleanups (old_chain
);
1395 /* This is the -data-read-memory command.
1397 ADDR: start address of data to be dumped.
1398 WORD-FORMAT: a char indicating format for the ``word''. See
1400 WORD-SIZE: size of each ``word''; 1,2,4, or 8 bytes.
1401 NR_ROW: Number of rows.
1402 NR_COL: The number of colums (words per row).
1403 ASCHAR: (OPTIONAL) Append an ascii character dump to each row. Use
1404 ASCHAR for unprintable characters.
1406 Reads SIZE*NR_ROW*NR_COL bytes starting at ADDR from memory and
1407 displayes them. Returns:
1409 {addr="...",rowN={wordN="..." ,... [,ascii="..."]}, ...}
1412 The number of bytes read is SIZE*ROW*COL. */
1415 mi_cmd_data_read_memory (char *command
, char **argv
, int argc
)
1417 struct gdbarch
*gdbarch
= get_current_arch ();
1418 struct ui_out
*uiout
= current_uiout
;
1419 struct cleanup
*cleanups
= make_cleanup (null_cleanup
, NULL
);
1421 long total_bytes
, nr_cols
, nr_rows
;
1423 struct type
*word_type
;
1436 static const struct mi_opt opts
[] =
1438 {"o", OFFSET_OPT
, 1},
1444 int opt
= mi_getopt ("-data-read-memory", argc
, argv
, opts
,
1449 switch ((enum opt
) opt
)
1452 offset
= atol (oarg
);
1459 if (argc
< 5 || argc
> 6)
1460 error (_("-data-read-memory: Usage: "
1461 "ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR]."));
1463 /* Extract all the arguments. */
1465 /* Start address of the memory dump. */
1466 addr
= parse_and_eval_address (argv
[0]) + offset
;
1467 /* The format character to use when displaying a memory word. See
1468 the ``x'' command. */
1469 word_format
= argv
[1][0];
1470 /* The size of the memory word. */
1471 word_size
= atol (argv
[2]);
1475 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1479 word_type
= builtin_type (gdbarch
)->builtin_int16
;
1483 word_type
= builtin_type (gdbarch
)->builtin_int32
;
1487 word_type
= builtin_type (gdbarch
)->builtin_int64
;
1491 word_type
= builtin_type (gdbarch
)->builtin_int8
;
1494 /* The number of rows. */
1495 nr_rows
= atol (argv
[3]);
1497 error (_("-data-read-memory: invalid number of rows."));
1499 /* Number of bytes per row. */
1500 nr_cols
= atol (argv
[4]);
1502 error (_("-data-read-memory: invalid number of columns."));
1504 /* The un-printable character when printing ascii. */
1510 /* Create a buffer and read it in. */
1511 total_bytes
= word_size
* nr_rows
* nr_cols
;
1512 mbuf
= XCNEWVEC (gdb_byte
, total_bytes
);
1513 make_cleanup (xfree
, mbuf
);
1515 /* Dispatch memory reads to the topmost target, not the flattened
1517 nr_bytes
= target_read (current_target
.beneath
,
1518 TARGET_OBJECT_MEMORY
, NULL
, mbuf
,
1521 error (_("Unable to read memory."));
1523 /* Output the header information. */
1524 ui_out_field_core_addr (uiout
, "addr", gdbarch
, addr
);
1525 ui_out_field_int (uiout
, "nr-bytes", nr_bytes
);
1526 ui_out_field_int (uiout
, "total-bytes", total_bytes
);
1527 ui_out_field_core_addr (uiout
, "next-row",
1528 gdbarch
, addr
+ word_size
* nr_cols
);
1529 ui_out_field_core_addr (uiout
, "prev-row",
1530 gdbarch
, addr
- word_size
* nr_cols
);
1531 ui_out_field_core_addr (uiout
, "next-page", gdbarch
, addr
+ total_bytes
);
1532 ui_out_field_core_addr (uiout
, "prev-page", gdbarch
, addr
- total_bytes
);
1534 /* Build the result as a two dimentional table. */
1536 struct ui_file
*stream
;
1537 struct cleanup
*cleanup_stream
;
1541 stream
= mem_fileopen ();
1542 cleanup_stream
= make_cleanup_ui_file_delete (stream
);
1544 make_cleanup_ui_out_list_begin_end (uiout
, "memory");
1545 for (row
= 0, row_byte
= 0;
1547 row
++, row_byte
+= nr_cols
* word_size
)
1551 struct cleanup
*cleanup_tuple
;
1552 struct cleanup
*cleanup_list_data
;
1553 struct value_print_options opts
;
1555 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1556 ui_out_field_core_addr (uiout
, "addr", gdbarch
, addr
+ row_byte
);
1557 /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr +
1559 cleanup_list_data
= make_cleanup_ui_out_list_begin_end (uiout
, "data");
1560 get_formatted_print_options (&opts
, word_format
);
1561 for (col
= 0, col_byte
= row_byte
;
1563 col
++, col_byte
+= word_size
)
1565 if (col_byte
+ word_size
> nr_bytes
)
1567 ui_out_field_string (uiout
, NULL
, "N/A");
1571 ui_file_rewind (stream
);
1572 print_scalar_formatted (mbuf
+ col_byte
, word_type
, &opts
,
1573 word_asize
, stream
);
1574 ui_out_field_stream (uiout
, NULL
, stream
);
1577 do_cleanups (cleanup_list_data
);
1582 ui_file_rewind (stream
);
1583 for (byte
= row_byte
;
1584 byte
< row_byte
+ word_size
* nr_cols
; byte
++)
1586 if (byte
>= nr_bytes
)
1587 fputc_unfiltered ('X', stream
);
1588 else if (mbuf
[byte
] < 32 || mbuf
[byte
] > 126)
1589 fputc_unfiltered (aschar
, stream
);
1591 fputc_unfiltered (mbuf
[byte
], stream
);
1593 ui_out_field_stream (uiout
, "ascii", stream
);
1595 do_cleanups (cleanup_tuple
);
1597 do_cleanups (cleanup_stream
);
1599 do_cleanups (cleanups
);
1603 mi_cmd_data_read_memory_bytes (char *command
, char **argv
, int argc
)
1605 struct gdbarch
*gdbarch
= get_current_arch ();
1606 struct ui_out
*uiout
= current_uiout
;
1607 struct cleanup
*cleanups
;
1610 memory_read_result_s
*read_result
;
1612 VEC(memory_read_result_s
) *result
;
1614 int unit_size
= gdbarch_addressable_memory_unit_size (gdbarch
);
1621 static const struct mi_opt opts
[] =
1623 {"o", OFFSET_OPT
, 1},
1629 int opt
= mi_getopt ("-data-read-memory-bytes", argc
, argv
, opts
,
1633 switch ((enum opt
) opt
)
1636 offset
= atol (oarg
);
1644 error (_("Usage: [ -o OFFSET ] ADDR LENGTH."));
1646 addr
= parse_and_eval_address (argv
[0]) + offset
;
1647 length
= atol (argv
[1]);
1649 result
= read_memory_robust (current_target
.beneath
, addr
, length
);
1651 cleanups
= make_cleanup (free_memory_read_result_vector
, &result
);
1653 if (VEC_length (memory_read_result_s
, result
) == 0)
1654 error (_("Unable to read memory."));
1656 make_cleanup_ui_out_list_begin_end (uiout
, "memory");
1658 VEC_iterate (memory_read_result_s
, result
, ix
, read_result
);
1661 struct cleanup
*t
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
1666 ui_out_field_core_addr (uiout
, "begin", gdbarch
, read_result
->begin
);
1667 ui_out_field_core_addr (uiout
, "offset", gdbarch
, read_result
->begin
1669 ui_out_field_core_addr (uiout
, "end", gdbarch
, read_result
->end
);
1671 alloc_len
= (read_result
->end
- read_result
->begin
) * 2 * unit_size
+ 1;
1672 data
= (char *) xmalloc (alloc_len
);
1674 for (i
= 0, p
= data
;
1675 i
< ((read_result
->end
- read_result
->begin
) * unit_size
);
1678 sprintf (p
, "%02x", read_result
->data
[i
]);
1680 ui_out_field_string (uiout
, "contents", data
);
1684 do_cleanups (cleanups
);
1687 /* Implementation of the -data-write_memory command.
1689 COLUMN_OFFSET: optional argument. Must be preceded by '-o'. The
1690 offset from the beginning of the memory grid row where the cell to
1692 ADDR: start address of the row in the memory grid where the memory
1693 cell is, if OFFSET_COLUMN is specified. Otherwise, the address of
1694 the location to write to.
1695 FORMAT: a char indicating format for the ``word''. See
1697 WORD_SIZE: size of each ``word''; 1,2,4, or 8 bytes
1698 VALUE: value to be written into the memory address.
1700 Writes VALUE into ADDR + (COLUMN_OFFSET * WORD_SIZE).
1705 mi_cmd_data_write_memory (char *command
, char **argv
, int argc
)
1707 struct gdbarch
*gdbarch
= get_current_arch ();
1708 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1711 /* FIXME: ezannoni 2000-02-17 LONGEST could possibly not be big
1712 enough when using a compiler other than GCC. */
1715 struct cleanup
*old_chain
;
1723 static const struct mi_opt opts
[] =
1725 {"o", OFFSET_OPT
, 1},
1731 int opt
= mi_getopt ("-data-write-memory", argc
, argv
, opts
,
1736 switch ((enum opt
) opt
)
1739 offset
= atol (oarg
);
1747 error (_("-data-write-memory: Usage: "
1748 "[-o COLUMN_OFFSET] ADDR FORMAT WORD-SIZE VALUE."));
1750 /* Extract all the arguments. */
1751 /* Start address of the memory dump. */
1752 addr
= parse_and_eval_address (argv
[0]);
1753 /* The size of the memory word. */
1754 word_size
= atol (argv
[2]);
1756 /* Calculate the real address of the write destination. */
1757 addr
+= (offset
* word_size
);
1759 /* Get the value as a number. */
1760 value
= parse_and_eval_address (argv
[3]);
1761 /* Get the value into an array. */
1762 buffer
= (gdb_byte
*) xmalloc (word_size
);
1763 old_chain
= make_cleanup (xfree
, buffer
);
1764 store_signed_integer (buffer
, word_size
, byte_order
, value
);
1765 /* Write it down to memory. */
1766 write_memory_with_notification (addr
, buffer
, word_size
);
1767 /* Free the buffer. */
1768 do_cleanups (old_chain
);
1771 /* Implementation of the -data-write-memory-bytes command.
1774 DATA: string of bytes to write at that address
1775 COUNT: number of bytes to be filled (decimal integer). */
1778 mi_cmd_data_write_memory_bytes (char *command
, char **argv
, int argc
)
1784 size_t len_hex
, len_bytes
, len_units
, i
, steps
, remaining_units
;
1785 long int count_units
;
1786 struct cleanup
*back_to
;
1789 if (argc
!= 2 && argc
!= 3)
1790 error (_("Usage: ADDR DATA [COUNT]."));
1792 addr
= parse_and_eval_address (argv
[0]);
1794 len_hex
= strlen (cdata
);
1795 unit_size
= gdbarch_addressable_memory_unit_size (get_current_arch ());
1797 if (len_hex
% (unit_size
* 2) != 0)
1798 error (_("Hex-encoded '%s' must represent an integral number of "
1799 "addressable memory units."),
1802 len_bytes
= len_hex
/ 2;
1803 len_units
= len_bytes
/ unit_size
;
1806 count_units
= strtoul (argv
[2], NULL
, 10);
1808 count_units
= len_units
;
1810 databuf
= XNEWVEC (gdb_byte
, len_bytes
);
1811 back_to
= make_cleanup (xfree
, databuf
);
1813 for (i
= 0; i
< len_bytes
; ++i
)
1816 if (sscanf (cdata
+ i
* 2, "%02x", &x
) != 1)
1817 error (_("Invalid argument"));
1818 databuf
[i
] = (gdb_byte
) x
;
1821 if (len_units
< count_units
)
1823 /* Pattern is made of less units than count:
1824 repeat pattern to fill memory. */
1825 data
= (gdb_byte
*) xmalloc (count_units
* unit_size
);
1826 make_cleanup (xfree
, data
);
1828 /* Number of times the pattern is entirely repeated. */
1829 steps
= count_units
/ len_units
;
1830 /* Number of remaining addressable memory units. */
1831 remaining_units
= count_units
% len_units
;
1832 for (i
= 0; i
< steps
; i
++)
1833 memcpy (data
+ i
* len_bytes
, databuf
, len_bytes
);
1835 if (remaining_units
> 0)
1836 memcpy (data
+ steps
* len_bytes
, databuf
,
1837 remaining_units
* unit_size
);
1841 /* Pattern is longer than or equal to count:
1842 just copy count addressable memory units. */
1846 write_memory_with_notification (addr
, data
, count_units
);
1848 do_cleanups (back_to
);
1852 mi_cmd_enable_timings (char *command
, char **argv
, int argc
)
1858 if (strcmp (argv
[0], "yes") == 0)
1860 else if (strcmp (argv
[0], "no") == 0)
1871 error (_("-enable-timings: Usage: %s {yes|no}"), command
);
1875 mi_cmd_list_features (char *command
, char **argv
, int argc
)
1879 struct cleanup
*cleanup
= NULL
;
1880 struct ui_out
*uiout
= current_uiout
;
1882 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "features");
1883 ui_out_field_string (uiout
, NULL
, "frozen-varobjs");
1884 ui_out_field_string (uiout
, NULL
, "pending-breakpoints");
1885 ui_out_field_string (uiout
, NULL
, "thread-info");
1886 ui_out_field_string (uiout
, NULL
, "data-read-memory-bytes");
1887 ui_out_field_string (uiout
, NULL
, "breakpoint-notifications");
1888 ui_out_field_string (uiout
, NULL
, "ada-task-info");
1889 ui_out_field_string (uiout
, NULL
, "language-option");
1890 ui_out_field_string (uiout
, NULL
, "info-gdb-mi-command");
1891 ui_out_field_string (uiout
, NULL
, "undefined-command-error-code");
1892 ui_out_field_string (uiout
, NULL
, "exec-run-start-option");
1894 if (ext_lang_initialized_p (get_ext_lang_defn (EXT_LANG_PYTHON
)))
1895 ui_out_field_string (uiout
, NULL
, "python");
1897 do_cleanups (cleanup
);
1901 error (_("-list-features should be passed no arguments"));
1905 mi_cmd_list_target_features (char *command
, char **argv
, int argc
)
1909 struct cleanup
*cleanup
= NULL
;
1910 struct ui_out
*uiout
= current_uiout
;
1912 cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "features");
1914 ui_out_field_string (uiout
, NULL
, "async");
1915 if (target_can_execute_reverse
)
1916 ui_out_field_string (uiout
, NULL
, "reverse");
1917 do_cleanups (cleanup
);
1921 error (_("-list-target-features should be passed no arguments"));
1925 mi_cmd_add_inferior (char *command
, char **argv
, int argc
)
1927 struct inferior
*inf
;
1930 error (_("-add-inferior should be passed no arguments"));
1932 inf
= add_inferior_with_spaces ();
1934 ui_out_field_fmt (current_uiout
, "inferior", "i%d", inf
->num
);
1937 /* Callback used to find the first inferior other than the current
1941 get_other_inferior (struct inferior
*inf
, void *arg
)
1943 if (inf
== current_inferior ())
1950 mi_cmd_remove_inferior (char *command
, char **argv
, int argc
)
1953 struct inferior
*inf
;
1956 error (_("-remove-inferior should be passed a single argument"));
1958 if (sscanf (argv
[0], "i%d", &id
) != 1)
1959 error (_("the thread group id is syntactically invalid"));
1961 inf
= find_inferior_id (id
);
1963 error (_("the specified thread group does not exist"));
1966 error (_("cannot remove an active inferior"));
1968 if (inf
== current_inferior ())
1970 struct thread_info
*tp
= 0;
1971 struct inferior
*new_inferior
1972 = iterate_over_inferiors (get_other_inferior
, NULL
);
1974 if (new_inferior
== NULL
)
1975 error (_("Cannot remove last inferior"));
1977 set_current_inferior (new_inferior
);
1978 if (new_inferior
->pid
!= 0)
1979 tp
= any_thread_of_process (new_inferior
->pid
);
1980 switch_to_thread (tp
? tp
->ptid
: null_ptid
);
1981 set_current_program_space (new_inferior
->pspace
);
1984 delete_inferior (inf
);
1989 /* Execute a command within a safe environment.
1990 Return <0 for error; >=0 for ok.
1992 args->action will tell mi_execute_command what action
1993 to perfrom after the given command has executed (display/suppress
1994 prompt, display error). */
1997 captured_mi_execute_command (struct ui_out
*uiout
, struct mi_parse
*context
)
1999 struct mi_interp
*mi
= (struct mi_interp
*) interp_data (command_interp ());
2000 struct cleanup
*cleanup
;
2003 current_command_ts
= context
->cmd_start
;
2005 current_token
= xstrdup (context
->token
);
2006 cleanup
= make_cleanup (free_current_contents
, ¤t_token
);
2008 running_result_record_printed
= 0;
2010 switch (context
->op
)
2013 /* A MI command was read from the input stream. */
2015 /* FIXME: gdb_???? */
2016 fprintf_unfiltered (mi
->raw_stdout
,
2017 " token=`%s' command=`%s' args=`%s'\n",
2018 context
->token
, context
->command
, context
->args
);
2020 mi_cmd_execute (context
);
2022 /* Print the result if there were no errors.
2024 Remember that on the way out of executing a command, you have
2025 to directly use the mi_interp's uiout, since the command
2026 could have reset the interpreter, in which case the current
2027 uiout will most likely crash in the mi_out_* routines. */
2028 if (!running_result_record_printed
)
2030 fputs_unfiltered (context
->token
, mi
->raw_stdout
);
2031 /* There's no particularly good reason why target-connect results
2032 in not ^done. Should kill ^connected for MI3. */
2033 fputs_unfiltered (strcmp (context
->command
, "target-select") == 0
2034 ? "^connected" : "^done", mi
->raw_stdout
);
2035 mi_out_put (uiout
, mi
->raw_stdout
);
2036 mi_out_rewind (uiout
);
2037 mi_print_timing_maybe (mi
->raw_stdout
);
2038 fputs_unfiltered ("\n", mi
->raw_stdout
);
2041 /* The command does not want anything to be printed. In that
2042 case, the command probably should not have written anything
2043 to uiout, but in case it has written something, discard it. */
2044 mi_out_rewind (uiout
);
2051 /* A CLI command was read from the input stream. */
2052 /* This "feature" will be removed as soon as we have a
2053 complete set of mi commands. */
2054 /* Echo the command on the console. */
2055 fprintf_unfiltered (gdb_stdlog
, "%s\n", context
->command
);
2056 /* Call the "console" interpreter. */
2057 argv
[0] = INTERP_CONSOLE
;
2058 argv
[1] = context
->command
;
2059 mi_cmd_interpreter_exec ("-interpreter-exec", argv
, 2);
2061 /* If we changed interpreters, DON'T print out anything. */
2062 if (current_interp_named_p (INTERP_MI
)
2063 || current_interp_named_p (INTERP_MI1
)
2064 || current_interp_named_p (INTERP_MI2
)
2065 || current_interp_named_p (INTERP_MI3
))
2067 if (!running_result_record_printed
)
2069 fputs_unfiltered (context
->token
, mi
->raw_stdout
);
2070 fputs_unfiltered ("^done", mi
->raw_stdout
);
2071 mi_out_put (uiout
, mi
->raw_stdout
);
2072 mi_out_rewind (uiout
);
2073 mi_print_timing_maybe (mi
->raw_stdout
);
2074 fputs_unfiltered ("\n", mi
->raw_stdout
);
2077 mi_out_rewind (uiout
);
2083 do_cleanups (cleanup
);
2086 /* Print a gdb exception to the MI output stream. */
2089 mi_print_exception (const char *token
, struct gdb_exception exception
)
2091 struct mi_interp
*mi
2092 = (struct mi_interp
*) interp_data (current_interpreter ());
2094 fputs_unfiltered (token
, mi
->raw_stdout
);
2095 fputs_unfiltered ("^error,msg=\"", mi
->raw_stdout
);
2096 if (exception
.message
== NULL
)
2097 fputs_unfiltered ("unknown error", mi
->raw_stdout
);
2099 fputstr_unfiltered (exception
.message
, '"', mi
->raw_stdout
);
2100 fputs_unfiltered ("\"", mi
->raw_stdout
);
2102 switch (exception
.error
)
2104 case UNDEFINED_COMMAND_ERROR
:
2105 fputs_unfiltered (",code=\"undefined-command\"", mi
->raw_stdout
);
2109 fputs_unfiltered ("\n", mi
->raw_stdout
);
2112 /* Determine whether the parsed command already notifies the
2113 user_selected_context_changed observer. */
2116 command_notifies_uscc_observer (struct mi_parse
*command
)
2118 if (command
->op
== CLI_COMMAND
)
2120 /* CLI commands "thread" and "inferior" already send it. */
2121 return (strncmp (command
->command
, "thread ", 7) == 0
2122 || strncmp (command
->command
, "inferior ", 9) == 0);
2124 else /* MI_COMMAND */
2126 if (strcmp (command
->command
, "interpreter-exec") == 0
2127 && command
->argc
> 1)
2129 /* "thread" and "inferior" again, but through -interpreter-exec. */
2130 return (strncmp (command
->argv
[1], "thread ", 7) == 0
2131 || strncmp (command
->argv
[1], "inferior ", 9) == 0);
2135 /* -thread-select already sends it. */
2136 return strcmp (command
->command
, "thread-select") == 0;
2141 mi_execute_command (const char *cmd
, int from_tty
)
2144 struct mi_parse
*command
= NULL
;
2146 /* This is to handle EOF (^D). We just quit gdb. */
2147 /* FIXME: we should call some API function here. */
2149 quit_force (NULL
, from_tty
);
2151 target_log_command (cmd
);
2155 command
= mi_parse (cmd
, &token
);
2157 CATCH (exception
, RETURN_MASK_ALL
)
2159 mi_print_exception (token
, exception
);
2164 if (command
!= NULL
)
2166 ptid_t previous_ptid
= inferior_ptid
;
2167 struct cleanup
*cleanup
= make_cleanup (null_cleanup
, NULL
);
2169 command
->token
= token
;
2171 if (command
->cmd
!= NULL
&& command
->cmd
->suppress_notification
!= NULL
)
2173 make_cleanup_restore_integer (command
->cmd
->suppress_notification
);
2174 *command
->cmd
->suppress_notification
= 1;
2179 command
->cmd_start
= XNEW (struct mi_timestamp
);
2180 timestamp (command
->cmd_start
);
2185 captured_mi_execute_command (current_uiout
, command
);
2187 CATCH (result
, RETURN_MASK_ALL
)
2189 /* Like in start_event_loop, enable input and force display
2190 of the prompt. Otherwise, any command that calls
2191 async_disable_stdin, and then throws, will leave input
2193 async_enable_stdin ();
2194 current_ui
->prompt_state
= PROMPT_NEEDED
;
2196 /* The command execution failed and error() was called
2198 mi_print_exception (command
->token
, result
);
2199 mi_out_rewind (current_uiout
);
2203 bpstat_do_actions ();
2205 if (/* The notifications are only output when the top-level
2206 interpreter (specified on the command line) is MI. */
2207 ui_out_is_mi_like_p (interp_ui_out (top_level_interpreter ()))
2208 /* Don't try report anything if there are no threads --
2209 the program is dead. */
2210 && thread_count () != 0
2211 /* If the command already reports the thread change, no need to do it
2213 && !command_notifies_uscc_observer (command
))
2215 struct mi_interp
*mi
2216 = (struct mi_interp
*) top_level_interpreter_data ();
2217 int report_change
= 0;
2219 if (command
->thread
== -1)
2221 report_change
= (!ptid_equal (previous_ptid
, null_ptid
)
2222 && !ptid_equal (inferior_ptid
, previous_ptid
)
2223 && !ptid_equal (inferior_ptid
, null_ptid
));
2225 else if (!ptid_equal (inferior_ptid
, null_ptid
))
2227 struct thread_info
*ti
= inferior_thread ();
2229 report_change
= (ti
->global_num
!= command
->thread
);
2234 observer_notify_user_selected_context_changed
2235 (USER_SELECTED_THREAD
| USER_SELECTED_FRAME
);
2239 mi_parse_free (command
);
2241 do_cleanups (cleanup
);
2246 mi_cmd_execute (struct mi_parse
*parse
)
2248 struct cleanup
*cleanup
;
2250 cleanup
= prepare_execute_command ();
2252 if (parse
->all
&& parse
->thread_group
!= -1)
2253 error (_("Cannot specify --thread-group together with --all"));
2255 if (parse
->all
&& parse
->thread
!= -1)
2256 error (_("Cannot specify --thread together with --all"));
2258 if (parse
->thread_group
!= -1 && parse
->thread
!= -1)
2259 error (_("Cannot specify --thread together with --thread-group"));
2261 if (parse
->frame
!= -1 && parse
->thread
== -1)
2262 error (_("Cannot specify --frame without --thread"));
2264 if (parse
->thread_group
!= -1)
2266 struct inferior
*inf
= find_inferior_id (parse
->thread_group
);
2267 struct thread_info
*tp
= 0;
2270 error (_("Invalid thread group for the --thread-group option"));
2272 set_current_inferior (inf
);
2273 /* This behaviour means that if --thread-group option identifies
2274 an inferior with multiple threads, then a random one will be
2275 picked. This is not a problem -- frontend should always
2276 provide --thread if it wishes to operate on a specific
2279 tp
= any_live_thread_of_process (inf
->pid
);
2280 switch_to_thread (tp
? tp
->ptid
: null_ptid
);
2281 set_current_program_space (inf
->pspace
);
2284 if (parse
->thread
!= -1)
2286 struct thread_info
*tp
= find_thread_global_id (parse
->thread
);
2289 error (_("Invalid thread id: %d"), parse
->thread
);
2291 if (is_exited (tp
->ptid
))
2292 error (_("Thread id: %d has terminated"), parse
->thread
);
2294 switch_to_thread (tp
->ptid
);
2297 if (parse
->frame
!= -1)
2299 struct frame_info
*fid
;
2300 int frame
= parse
->frame
;
2302 fid
= find_relative_frame (get_current_frame (), &frame
);
2304 /* find_relative_frame was successful */
2307 error (_("Invalid frame id: %d"), frame
);
2310 if (parse
->language
!= language_unknown
)
2312 make_cleanup_restore_current_language ();
2313 set_language (parse
->language
);
2316 current_context
= parse
;
2318 if (parse
->cmd
->argv_func
!= NULL
)
2320 parse
->cmd
->argv_func (parse
->command
, parse
->argv
, parse
->argc
);
2322 else if (parse
->cmd
->cli
.cmd
!= 0)
2324 /* FIXME: DELETE THIS. */
2325 /* The operation is still implemented by a cli command. */
2326 /* Must be a synchronous one. */
2327 mi_execute_cli_command (parse
->cmd
->cli
.cmd
, parse
->cmd
->cli
.args_p
,
2332 /* FIXME: DELETE THIS. */
2333 struct ui_file
*stb
;
2335 stb
= mem_fileopen ();
2337 fputs_unfiltered ("Undefined mi command: ", stb
);
2338 fputstr_unfiltered (parse
->command
, '"', stb
);
2339 fputs_unfiltered (" (missing implementation)", stb
);
2341 make_cleanup_ui_file_delete (stb
);
2344 do_cleanups (cleanup
);
2347 /* FIXME: This is just a hack so we can get some extra commands going.
2348 We don't want to channel things through the CLI, but call libgdb directly.
2349 Use only for synchronous commands. */
2352 mi_execute_cli_command (const char *cmd
, int args_p
, const char *args
)
2356 struct cleanup
*old_cleanups
;
2360 run
= xstrprintf ("%s %s", cmd
, args
);
2362 run
= xstrdup (cmd
);
2364 /* FIXME: gdb_???? */
2365 fprintf_unfiltered (gdb_stdout
, "cli=%s run=%s\n",
2367 old_cleanups
= make_cleanup (xfree
, run
);
2368 execute_command (run
, 0 /* from_tty */ );
2369 do_cleanups (old_cleanups
);
2375 mi_execute_async_cli_command (char *cli_command
, char **argv
, int argc
)
2377 struct cleanup
*old_cleanups
;
2381 run
= xstrprintf ("%s %s&", cli_command
, argc
? *argv
: "");
2383 run
= xstrprintf ("%s %s", cli_command
, argc
? *argv
: "");
2384 old_cleanups
= make_cleanup (xfree
, run
);
2386 execute_command (run
, 0 /* from_tty */ );
2388 /* Do this before doing any printing. It would appear that some
2389 print code leaves garbage around in the buffer. */
2390 do_cleanups (old_cleanups
);
2394 mi_load_progress (const char *section_name
,
2395 unsigned long sent_so_far
,
2396 unsigned long total_section
,
2397 unsigned long total_sent
,
2398 unsigned long grand_total
)
2400 struct timeval time_now
, delta
, update_threshold
;
2401 static struct timeval last_update
;
2402 static char *previous_sect_name
= NULL
;
2404 struct ui_out
*saved_uiout
;
2405 struct ui_out
*uiout
;
2406 struct mi_interp
*mi
2407 = (struct mi_interp
*) interp_data (current_interpreter ());
2409 /* This function is called through deprecated_show_load_progress
2410 which means uiout may not be correct. Fix it for the duration
2411 of this function. */
2412 saved_uiout
= current_uiout
;
2414 if (current_interp_named_p (INTERP_MI
)
2415 || current_interp_named_p (INTERP_MI2
))
2416 current_uiout
= mi_out_new (2);
2417 else if (current_interp_named_p (INTERP_MI1
))
2418 current_uiout
= mi_out_new (1);
2419 else if (current_interp_named_p (INTERP_MI3
))
2420 current_uiout
= mi_out_new (3);
2424 uiout
= current_uiout
;
2426 update_threshold
.tv_sec
= 0;
2427 update_threshold
.tv_usec
= 500000;
2428 gettimeofday (&time_now
, NULL
);
2430 delta
.tv_usec
= time_now
.tv_usec
- last_update
.tv_usec
;
2431 delta
.tv_sec
= time_now
.tv_sec
- last_update
.tv_sec
;
2433 if (delta
.tv_usec
< 0)
2436 delta
.tv_usec
+= 1000000L;
2439 new_section
= (previous_sect_name
?
2440 strcmp (previous_sect_name
, section_name
) : 1);
2443 struct cleanup
*cleanup_tuple
;
2445 xfree (previous_sect_name
);
2446 previous_sect_name
= xstrdup (section_name
);
2449 fputs_unfiltered (current_token
, mi
->raw_stdout
);
2450 fputs_unfiltered ("+download", mi
->raw_stdout
);
2451 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2452 ui_out_field_string (uiout
, "section", section_name
);
2453 ui_out_field_int (uiout
, "section-size", total_section
);
2454 ui_out_field_int (uiout
, "total-size", grand_total
);
2455 do_cleanups (cleanup_tuple
);
2456 mi_out_put (uiout
, mi
->raw_stdout
);
2457 fputs_unfiltered ("\n", mi
->raw_stdout
);
2458 gdb_flush (mi
->raw_stdout
);
2461 if (delta
.tv_sec
>= update_threshold
.tv_sec
&&
2462 delta
.tv_usec
>= update_threshold
.tv_usec
)
2464 struct cleanup
*cleanup_tuple
;
2466 last_update
.tv_sec
= time_now
.tv_sec
;
2467 last_update
.tv_usec
= time_now
.tv_usec
;
2469 fputs_unfiltered (current_token
, mi
->raw_stdout
);
2470 fputs_unfiltered ("+download", mi
->raw_stdout
);
2471 cleanup_tuple
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2472 ui_out_field_string (uiout
, "section", section_name
);
2473 ui_out_field_int (uiout
, "section-sent", sent_so_far
);
2474 ui_out_field_int (uiout
, "section-size", total_section
);
2475 ui_out_field_int (uiout
, "total-sent", total_sent
);
2476 ui_out_field_int (uiout
, "total-size", grand_total
);
2477 do_cleanups (cleanup_tuple
);
2478 mi_out_put (uiout
, mi
->raw_stdout
);
2479 fputs_unfiltered ("\n", mi
->raw_stdout
);
2480 gdb_flush (mi
->raw_stdout
);
2484 current_uiout
= saved_uiout
;
2488 timestamp (struct mi_timestamp
*tv
)
2490 gettimeofday (&tv
->wallclock
, NULL
);
2491 #ifdef HAVE_GETRUSAGE
2492 getrusage (RUSAGE_SELF
, &rusage
);
2493 tv
->utime
.tv_sec
= rusage
.ru_utime
.tv_sec
;
2494 tv
->utime
.tv_usec
= rusage
.ru_utime
.tv_usec
;
2495 tv
->stime
.tv_sec
= rusage
.ru_stime
.tv_sec
;
2496 tv
->stime
.tv_usec
= rusage
.ru_stime
.tv_usec
;
2499 long usec
= get_run_time ();
2501 tv
->utime
.tv_sec
= usec
/1000000L;
2502 tv
->utime
.tv_usec
= usec
- 1000000L*tv
->utime
.tv_sec
;
2503 tv
->stime
.tv_sec
= 0;
2504 tv
->stime
.tv_usec
= 0;
2510 print_diff_now (struct ui_file
*file
, struct mi_timestamp
*start
)
2512 struct mi_timestamp now
;
2515 print_diff (file
, start
, &now
);
2519 mi_print_timing_maybe (struct ui_file
*file
)
2521 /* If the command is -enable-timing then do_timings may be true
2522 whilst current_command_ts is not initialized. */
2523 if (do_timings
&& current_command_ts
)
2524 print_diff_now (file
, current_command_ts
);
2528 timeval_diff (struct timeval start
, struct timeval end
)
2530 return ((end
.tv_sec
- start
.tv_sec
) * 1000000L)
2531 + (end
.tv_usec
- start
.tv_usec
);
2535 print_diff (struct ui_file
*file
, struct mi_timestamp
*start
,
2536 struct mi_timestamp
*end
)
2540 ",time={wallclock=\"%0.5f\",user=\"%0.5f\",system=\"%0.5f\"}",
2541 timeval_diff (start
->wallclock
, end
->wallclock
) / 1000000.0,
2542 timeval_diff (start
->utime
, end
->utime
) / 1000000.0,
2543 timeval_diff (start
->stime
, end
->stime
) / 1000000.0);
2547 mi_cmd_trace_define_variable (char *command
, char **argv
, int argc
)
2549 LONGEST initval
= 0;
2550 struct trace_state_variable
*tsv
;
2553 if (argc
!= 1 && argc
!= 2)
2554 error (_("Usage: -trace-define-variable VARIABLE [VALUE]"));
2558 error (_("Name of trace variable should start with '$'"));
2560 validate_trace_state_variable_name (name
);
2562 tsv
= find_trace_state_variable (name
);
2564 tsv
= create_trace_state_variable (name
);
2567 initval
= value_as_long (parse_and_eval (argv
[1]));
2569 tsv
->initial_value
= initval
;
2573 mi_cmd_trace_list_variables (char *command
, char **argv
, int argc
)
2576 error (_("-trace-list-variables: no arguments allowed"));
2578 tvariables_info_1 ();
2582 mi_cmd_trace_find (char *command
, char **argv
, int argc
)
2587 error (_("trace selection mode is required"));
2591 if (strcmp (mode
, "none") == 0)
2593 tfind_1 (tfind_number
, -1, 0, 0, 0);
2597 check_trace_running (current_trace_status ());
2599 if (strcmp (mode
, "frame-number") == 0)
2602 error (_("frame number is required"));
2603 tfind_1 (tfind_number
, atoi (argv
[1]), 0, 0, 0);
2605 else if (strcmp (mode
, "tracepoint-number") == 0)
2608 error (_("tracepoint number is required"));
2609 tfind_1 (tfind_tp
, atoi (argv
[1]), 0, 0, 0);
2611 else if (strcmp (mode
, "pc") == 0)
2614 error (_("PC is required"));
2615 tfind_1 (tfind_pc
, 0, parse_and_eval_address (argv
[1]), 0, 0);
2617 else if (strcmp (mode
, "pc-inside-range") == 0)
2620 error (_("Start and end PC are required"));
2621 tfind_1 (tfind_range
, 0, parse_and_eval_address (argv
[1]),
2622 parse_and_eval_address (argv
[2]), 0);
2624 else if (strcmp (mode
, "pc-outside-range") == 0)
2627 error (_("Start and end PC are required"));
2628 tfind_1 (tfind_outside
, 0, parse_and_eval_address (argv
[1]),
2629 parse_and_eval_address (argv
[2]), 0);
2631 else if (strcmp (mode
, "line") == 0)
2633 struct symtabs_and_lines sals
;
2634 struct symtab_and_line sal
;
2635 static CORE_ADDR start_pc
, end_pc
;
2636 struct cleanup
*back_to
;
2639 error (_("Line is required"));
2641 sals
= decode_line_with_current_source (argv
[1],
2642 DECODE_LINE_FUNFIRSTLINE
);
2643 back_to
= make_cleanup (xfree
, sals
.sals
);
2647 if (sal
.symtab
== 0)
2648 error (_("Could not find the specified line"));
2650 if (sal
.line
> 0 && find_line_pc_range (sal
, &start_pc
, &end_pc
))
2651 tfind_1 (tfind_range
, 0, start_pc
, end_pc
- 1, 0);
2653 error (_("Could not find the specified line"));
2655 do_cleanups (back_to
);
2658 error (_("Invalid mode '%s'"), mode
);
2660 if (has_stack_frames () || get_traceframe_number () >= 0)
2661 print_stack_frame (get_selected_frame (NULL
), 1, LOC_AND_ADDRESS
, 1);
2665 mi_cmd_trace_save (char *command
, char **argv
, int argc
)
2667 int target_saves
= 0;
2668 int generate_ctf
= 0;
2675 TARGET_SAVE_OPT
, CTF_OPT
2677 static const struct mi_opt opts
[] =
2679 {"r", TARGET_SAVE_OPT
, 0},
2680 {"ctf", CTF_OPT
, 0},
2686 int opt
= mi_getopt ("-trace-save", argc
, argv
, opts
,
2691 switch ((enum opt
) opt
)
2693 case TARGET_SAVE_OPT
:
2702 if (argc
- oind
!= 1)
2703 error (_("Exactly one argument required "
2704 "(file in which to save trace data)"));
2706 filename
= argv
[oind
];
2709 trace_save_ctf (filename
, target_saves
);
2711 trace_save_tfile (filename
, target_saves
);
2715 mi_cmd_trace_start (char *command
, char **argv
, int argc
)
2717 start_tracing (NULL
);
2721 mi_cmd_trace_status (char *command
, char **argv
, int argc
)
2723 trace_status_mi (0);
2727 mi_cmd_trace_stop (char *command
, char **argv
, int argc
)
2729 stop_tracing (NULL
);
2730 trace_status_mi (1);
2733 /* Implement the "-ada-task-info" command. */
2736 mi_cmd_ada_task_info (char *command
, char **argv
, int argc
)
2738 if (argc
!= 0 && argc
!= 1)
2739 error (_("Invalid MI command"));
2741 print_ada_task_info (current_uiout
, argv
[0], current_inferior ());
2744 /* Print EXPRESSION according to VALUES. */
2747 print_variable_or_computed (char *expression
, enum print_values values
)
2749 struct expression
*expr
;
2750 struct cleanup
*old_chain
;
2752 struct ui_file
*stb
;
2754 struct ui_out
*uiout
= current_uiout
;
2756 stb
= mem_fileopen ();
2757 old_chain
= make_cleanup_ui_file_delete (stb
);
2759 expr
= parse_expression (expression
);
2761 make_cleanup (free_current_contents
, &expr
);
2763 if (values
== PRINT_SIMPLE_VALUES
)
2764 val
= evaluate_type (expr
);
2766 val
= evaluate_expression (expr
);
2768 if (values
!= PRINT_NO_VALUES
)
2769 make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2770 ui_out_field_string (uiout
, "name", expression
);
2774 case PRINT_SIMPLE_VALUES
:
2775 type
= check_typedef (value_type (val
));
2776 type_print (value_type (val
), "", stb
, -1);
2777 ui_out_field_stream (uiout
, "type", stb
);
2778 if (TYPE_CODE (type
) != TYPE_CODE_ARRAY
2779 && TYPE_CODE (type
) != TYPE_CODE_STRUCT
2780 && TYPE_CODE (type
) != TYPE_CODE_UNION
)
2782 struct value_print_options opts
;
2784 get_no_prettyformat_print_options (&opts
);
2786 common_val_print (val
, stb
, 0, &opts
, current_language
);
2787 ui_out_field_stream (uiout
, "value", stb
);
2790 case PRINT_ALL_VALUES
:
2792 struct value_print_options opts
;
2794 get_no_prettyformat_print_options (&opts
);
2796 common_val_print (val
, stb
, 0, &opts
, current_language
);
2797 ui_out_field_stream (uiout
, "value", stb
);
2802 do_cleanups (old_chain
);
2805 /* Implement the "-trace-frame-collected" command. */
2808 mi_cmd_trace_frame_collected (char *command
, char **argv
, int argc
)
2810 struct cleanup
*old_chain
;
2811 struct bp_location
*tloc
;
2813 struct collection_list
*clist
;
2814 struct collection_list tracepoint_list
, stepping_list
;
2815 struct traceframe_info
*tinfo
;
2817 enum print_values var_print_values
= PRINT_ALL_VALUES
;
2818 enum print_values comp_print_values
= PRINT_ALL_VALUES
;
2819 int registers_format
= 'x';
2820 int memory_contents
= 0;
2821 struct ui_out
*uiout
= current_uiout
;
2829 static const struct mi_opt opts
[] =
2831 {"-var-print-values", VAR_PRINT_VALUES
, 1},
2832 {"-comp-print-values", COMP_PRINT_VALUES
, 1},
2833 {"-registers-format", REGISTERS_FORMAT
, 1},
2834 {"-memory-contents", MEMORY_CONTENTS
, 0},
2841 int opt
= mi_getopt ("-trace-frame-collected", argc
, argv
, opts
,
2845 switch ((enum opt
) opt
)
2847 case VAR_PRINT_VALUES
:
2848 var_print_values
= mi_parse_print_values (oarg
);
2850 case COMP_PRINT_VALUES
:
2851 comp_print_values
= mi_parse_print_values (oarg
);
2853 case REGISTERS_FORMAT
:
2854 registers_format
= oarg
[0];
2855 case MEMORY_CONTENTS
:
2856 memory_contents
= 1;
2862 error (_("Usage: -trace-frame-collected "
2863 "[--var-print-values PRINT_VALUES] "
2864 "[--comp-print-values PRINT_VALUES] "
2865 "[--registers-format FORMAT]"
2866 "[--memory-contents]"));
2868 /* This throws an error is not inspecting a trace frame. */
2869 tloc
= get_traceframe_location (&stepping_frame
);
2871 /* This command only makes sense for the current frame, not the
2873 old_chain
= make_cleanup_restore_current_thread ();
2874 select_frame (get_current_frame ());
2876 encode_actions_and_make_cleanup (tloc
, &tracepoint_list
,
2880 clist
= &stepping_list
;
2882 clist
= &tracepoint_list
;
2884 tinfo
= get_traceframe_info ();
2886 /* Explicitly wholly collected variables. */
2888 struct cleanup
*list_cleanup
;
2892 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
,
2893 "explicit-variables");
2894 for (i
= 0; VEC_iterate (char_ptr
, clist
->wholly_collected
, i
, p
); i
++)
2895 print_variable_or_computed (p
, var_print_values
);
2896 do_cleanups (list_cleanup
);
2899 /* Computed expressions. */
2901 struct cleanup
*list_cleanup
;
2906 = make_cleanup_ui_out_list_begin_end (uiout
,
2907 "computed-expressions");
2908 for (i
= 0; VEC_iterate (char_ptr
, clist
->computed
, i
, p
); i
++)
2909 print_variable_or_computed (p
, comp_print_values
);
2910 do_cleanups (list_cleanup
);
2913 /* Registers. Given pseudo-registers, and that some architectures
2914 (like MIPS) actually hide the raw registers, we don't go through
2915 the trace frame info, but instead consult the register cache for
2916 register availability. */
2918 struct cleanup
*list_cleanup
;
2919 struct frame_info
*frame
;
2920 struct gdbarch
*gdbarch
;
2924 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "registers");
2926 frame
= get_selected_frame (NULL
);
2927 gdbarch
= get_frame_arch (frame
);
2928 numregs
= gdbarch_num_regs (gdbarch
) + gdbarch_num_pseudo_regs (gdbarch
);
2930 for (regnum
= 0; regnum
< numregs
; regnum
++)
2932 if (gdbarch_register_name (gdbarch
, regnum
) == NULL
2933 || *(gdbarch_register_name (gdbarch
, regnum
)) == '\0')
2936 output_register (frame
, regnum
, registers_format
, 1);
2939 do_cleanups (list_cleanup
);
2942 /* Trace state variables. */
2944 struct cleanup
*list_cleanup
;
2949 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "tvars");
2952 make_cleanup (free_current_contents
, &tsvname
);
2954 for (i
= 0; VEC_iterate (int, tinfo
->tvars
, i
, tvar
); i
++)
2956 struct cleanup
*cleanup_child
;
2957 struct trace_state_variable
*tsv
;
2959 tsv
= find_trace_state_variable_by_number (tvar
);
2961 cleanup_child
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
2965 tsvname
= (char *) xrealloc (tsvname
, strlen (tsv
->name
) + 2);
2967 strcpy (tsvname
+ 1, tsv
->name
);
2968 ui_out_field_string (uiout
, "name", tsvname
);
2970 tsv
->value_known
= target_get_trace_state_variable_value (tsv
->number
,
2972 ui_out_field_int (uiout
, "current", tsv
->value
);
2976 ui_out_field_skip (uiout
, "name");
2977 ui_out_field_skip (uiout
, "current");
2980 do_cleanups (cleanup_child
);
2983 do_cleanups (list_cleanup
);
2988 struct cleanup
*list_cleanup
;
2989 VEC(mem_range_s
) *available_memory
= NULL
;
2990 struct mem_range
*r
;
2993 traceframe_available_memory (&available_memory
, 0, ULONGEST_MAX
);
2994 make_cleanup (VEC_cleanup(mem_range_s
), &available_memory
);
2996 list_cleanup
= make_cleanup_ui_out_list_begin_end (uiout
, "memory");
2998 for (i
= 0; VEC_iterate (mem_range_s
, available_memory
, i
, r
); i
++)
3000 struct cleanup
*cleanup_child
;
3002 struct gdbarch
*gdbarch
= target_gdbarch ();
3004 cleanup_child
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
3006 ui_out_field_core_addr (uiout
, "address", gdbarch
, r
->start
);
3007 ui_out_field_int (uiout
, "length", r
->length
);
3009 data
= (gdb_byte
*) xmalloc (r
->length
);
3010 make_cleanup (xfree
, data
);
3012 if (memory_contents
)
3014 if (target_read_memory (r
->start
, data
, r
->length
) == 0)
3019 data_str
= (char *) xmalloc (r
->length
* 2 + 1);
3020 make_cleanup (xfree
, data_str
);
3022 for (m
= 0, p
= data_str
; m
< r
->length
; ++m
, p
+= 2)
3023 sprintf (p
, "%02x", data
[m
]);
3024 ui_out_field_string (uiout
, "contents", data_str
);
3027 ui_out_field_skip (uiout
, "contents");
3029 do_cleanups (cleanup_child
);
3032 do_cleanups (list_cleanup
);
3035 do_cleanups (old_chain
);
3039 _initialize_mi_main (void)
3041 struct cmd_list_element
*c
;
3043 add_setshow_boolean_cmd ("mi-async", class_run
,
3045 Set whether MI asynchronous mode is enabled."), _("\
3046 Show whether MI asynchronous mode is enabled."), _("\
3047 Tells GDB whether MI should be in asynchronous mode."),
3048 set_mi_async_command
,
3049 show_mi_async_command
,
3053 /* Alias old "target-async" to "mi-async". */
3054 c
= add_alias_cmd ("target-async", "mi-async", class_run
, 0, &setlist
);
3055 deprecate_cmd (c
, "set mi-async");
3056 c
= add_alias_cmd ("target-async", "mi-async", class_run
, 0, &showlist
);
3057 deprecate_cmd (c
, "show mi-async");